Prerequisites¶

Ubuntu server 14.04 or newer.

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install -y libpq-dev python-dev python-pip libatlas-base-dev \
gfortran build-essential g++ npm libxml2-dev libxslt1-dev git mercurial \
libssl-dev curl uwsgi-core uwsgi-plugin-python

PostgreSQL and Redis are not included in the above commands. For a quick installation on AWS it is okay to install PostgreSQL and Redis locally on the AWS instance. If a more permanent and scalable solution, it is recommended to use AWS’s hosted Redis (ElastiCache) and PostgreSQL service.

# To install PostgreSQL and Redis locally
sudo apt-get install redis-server
sudo apt-get install postgresql postgresql-contrib

Python Dependencies¶

Clone the SEED repository from github

$ git clone git@github.com:SEED-platform/seed.git

enter the repo and install the python dependencies from requirements

$ cd seed
$ sudo pip install -r requirements/local.txt

JavaScript Dependencies¶

npm is required to install the JS dependencies. The bin/install_javascript_dependencies.sh script will download all JavaScript dependencies and build them. bower and gulp should be installed globally for convenience.

$ sudo apt-get install build-essential
$ sudo apt-get install curl

$ sudo npm install -g bower gulp
$ bin/install_javascript_dependencies.sh

Database Configuration¶

Copy the local_untracked.py.dist file in the config/settings directory to config/settings/local_untracked.py, and add a DATABASES configuration with your database username, password, host, and port. Your database configuration can point to an AWS RDS instance or a PostgreSQL 9.4 database instance you have manually installed within your infrastructure.

# Database
DATABASES = {
    'default': {
        'ENGINE':'django.db.backends.postgresql_psycopg2',
        'NAME': 'seed',
        'USER': '',
        'PASSWORD': '',
        'HOST': '',
        'PORT': '',
    }
}

In the above database configuration, seed is the database name, this is arbitrary and any valid name can be used as long as the database exists.

create the database within the postgres psql shell:

CREATE DATABASE seed;

or from the command line:

createdb seed

create the database tables and migrations:

python manage.py syncdb
python manage.py migrate

create a superuser to access the system

$ python manage.py create_default_user --username=demo@example.com --organization=example --password=demo123

Cache and Message Broker¶

The SEED project relies on redis for both cache and message brokering, and is available as an AWS ElastiCache service. local_untracked.py should be updated with the CACHES and BROKER_URL settings.

CACHES = {
    'default': {
        'BACKEND': 'redis_cache.cache.RedisCache',
        'LOCATION': "seed-core-cache.ntmprk.0001.usw2.cache.amazonaws.com:6379",
        'OPTIONS': { 'DB': 1 },
        'TIMEOUT': 300
    }
}
BROKER_URL = 'redis://seed-core-cache.ntmprk.0001.usw2.cache.amazonaws.com:6379/1'

Running Celery the Background Task Worker¶

Celery is used for background tasks (saving data, matching, creating projects, etc) and must be connected to the message broker queue. From the project directory, celery can be started:

celery -A seed worker -l INFO -c 2 -B --events --maxtasksperchild 1000

Running the Development Web Server¶

The Django dev server (not for production use) can be a quick and easy way to get an instance up and running. The dev server runs by default on port 8000 and can be run on any port. See Django’s runserver documentation for more options.

$ ./manage.py runserver

Running a Production Web Server¶

Our recommended web server is uwsgi sitting behind nginx. The bin/start_uwsgi.sh script can been created to start uwsgi assuming your Ubuntu user is named ubuntu.

Also, static assets will need to be moved to S3 for production use. The bin/post_compile script contains a list of commands to move assets to S3.

$ bin/post_compile

$ bin/start_uwsgi

The following environment variables can be set within the ~/.bashrc file to override default Django settings.

export SENTRY_DSN=https://xyz@app.getsentry.com/123
export DEBUG=False
export ONLY_HTTPS=True

Prerequisites¶

Ubuntu server 14.04 or newer

Install the following base packages to run SEED:

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install libpq-dev python-dev python-pip libatlas-base-dev \
gfortran build-essential g++ npm libxml2-dev libxslt1-dev git mercurial \
libssl-dev curl uwsgi-core uwsgi-plugin-python
sudo apt-get install redis-server
sudo apt-get install postgresql postgresql-contrib

Configure PostgreSQL¶

$ sudo su - postgres
$ createdb "seed-deploy"
$ createuser -P DBUsername
$ psql
postgres=# GRANT ALL PRIVILEGES ON DATABASE "seed-deploy" TO DBUsername;
postgres=# \q
$ exit

Python Dependencies¶

clone the seed repository from github

$ git clone git@github.com:SEED-platform/seed.git

enter the repo and install the python dependencies from requirements

$ cd seed
$ sudo pip install -r requirements/local.txt

JavaScript Dependencies¶

npm is required to install the JS dependencies. The bin/install_javascript_dependencies.sh script will download all JavaScript dependencies and build them. bower and gulp should be installed globally for convenience.

$ curl -sL https://deb.nodesource.com/setup_5.x | sudo -E bash -
$ sudo apt-get install -y nodejs
$ sudo npm install -g bower gulp

$ bin/install_javascript_dependencies.sh

Django Database Configuration¶

Copy the local_untracked.py.dist file in the config/settings directory to config/settings/local_untracked.py, and add a DATABASES configuration with your database username, password, host, and port. Your database configuration can point to an AWS RDS instance or a PostgreSQL 9.4 database instance you have manually installed within your infrastructure.

# Database
DATABASES = {
    'default': {
        'ENGINE':'django.db.backends.postgresql_psycopg2',
        'NAME': 'seed-deploy',
        'USER': 'DBUsername',
        'PASSWORD': '',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

In in the above database configuration, seed is the database name, this is arbitrary and any valid name can be used as long as the database exists. Enter the database name, user, password you set above.

The database settings can be tested using the Django management command, ./manage.py dbshell to connect to the configured database.

create the database tables and migrations:

$ python manage.py migrate

Cache and Message Broker¶

The SEED project relies on redis for both cache and message brokering, and is available as an AWS ElastiCache service or with the redis-server Linux package. (sudo apt-get install redis-server)

local_untracked.py should be updated with the CACHES and BROKER_URL settings.

CACHES = {
    'default': {
        'BACKEND': 'redis_cache.cache.RedisCache',
        'LOCATION': "127.0.0.1:6379",
        'OPTIONS': {'DB': 1},
        'TIMEOUT': 300
    }
}
BROKER_URL = 'redis://127.0.0.1:6379/1'

Creating the initial user¶

create a superuser to access the system

$ python manage.py create_default_user --username=demo@example.com --organization=example --password=demo123

Running celery the background task worker¶

Celery is used for background tasks (saving data, matching, creating projects, etc) and must be connected to the message broker queue. From the project directory, celery can be started:

celery -A seed worker -l INFO -c 2 -B --events --maxtasksperchild 1000

Running the development web server¶

The Django dev server (not for production use) can be a quick and easy way to get an instance up and running. The dev server runs by default on port 8000 and can be run on any port. See Django’s runserver documentation for more options.

$ python manage.py runserver --settings=config.settings.dev

Running a production web server¶

Our recommended web server is uwsgi sitting behind nginx. The python package uwsgi is needed for this, and should install to /usr/local/bin/uwsgi Since AWS S3, is not being used here, we recommend using dj-static to load static files.

$ sudo pip install uwsgi dj-static

Generate static files:

$ sudo ./manage.py collectstatic --settings=config.settings.dev

Update config/settings/local_untracked.py:

DEBUG = False
# static files
STATIC_ROOT = 'collected_static'
STATIC_URL = '/static/'

Start the web server:

$ sudo /usr/local/bin/uwsgi --http :80 --module standalone_uwsgi --max-requests 5000 --pidfile /tmp/uwsgi.pid --single-interpreter --enable-threads --cheaper-initial 1 -p 4

environmental variables¶

The following environment variables can be set within the ~/.bashrc file to override default Django settings.

export SENTRY_DSN=https://xyz@app.getsentry.com/123
export DEBUG=False
export ONLY_HTTPS=True

SMTP service¶

In the AWS setup, we use SES to provide an email service Django can use as an email backend and configured it in our config/settings/main.py:

EMAIL_BACKEND = 'django_ses.SESBackend'

Many options for setting up your own SMTP service/server or using other SMTP third party services are available and compatible including gmail.

Django can likewise send emails via python’s smtplib with sendmail or postfix installed. See their docs for more info.

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'

local_untracked.py¶

# PostgreSQL DB config
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'seed',
        'USER': 'your-username',
        'PASSWORD': 'your-password',
        'HOST': 'your-host',
        'PORT': 'your-port',
    }
}

# config for local storage backend
DEFAULT_FILE_STORAGE = 'django.core.files.storage.FileSystemStorage'
STATICFILES_STORAGE = DEFAULT_FILE_STORAGE
DOMAIN_URLCONFS = {}
DOMAIN_URLCONFS['default'] = 'urls.main'

CACHES = {
    'default': {
        'BACKEND': 'redis_cache.cache.RedisCache',
        'LOCATION': "127.0.0.1:6379",
        'OPTIONS': {'DB': 1},
        'TIMEOUT': 300
    }
}

# redis celery config
BROKER_URL = 'redis://127.0.0.1:6379/1'
CELERY_DEFAULT_QUEUE = 'seed-dev'
CELERY_QUEUES = (
    Queue(
        CELERY_DEFAULT_QUEUE,
        Exchange(CELERY_DEFAULT_QUEUE),
        routing_key=CELERY_DEFAULT_QUEUE
    ),
)

# SMTP config
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'

# static files
STATIC_ROOT = 'collected_static'
STATIC_URL = '/static/'

Submodules¶

Models¶

class seed.audit_logs.models.AuditLog(*args, **kwargs)¶

Bases: django_extensions.db.models.TimeStampedModel

An audit log of events and notes. Inherits created and modified from TimeStampedModel

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception AuditLog.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

AuditLog.action_response¶

A placeholder class that provides a way to set the attribute on the model.

AuditLog.content_object¶

Provide a generic many-to-one relation through the content_type and object_id fields.

This class also doubles as an accessor to the related object (similar to ForwardManyToOneDescriptor) by adding itself as a model attribute.

AuditLog.content_type¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

AuditLog.get_audit_type_display(*moreargs, **morekwargs)¶

AuditLog.get_next_by_created(*moreargs, **morekwargs)¶

AuditLog.get_next_by_modified(*moreargs, **morekwargs)¶

AuditLog.get_previous_by_created(*moreargs, **morekwargs)¶

AuditLog.get_previous_by_modified(*moreargs, **morekwargs)¶

AuditLog.objects = <seed.audit_logs.models.AuditLogManager object>¶

AuditLog.organization¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

AuditLog.save(*args, **kwargs)¶

Ensure that only notes are saved

AuditLog.to_dict()¶

serializes an audit_log

AuditLog.user¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

class seed.audit_logs.models.AuditLogManager¶

Bases: django.db.models.manager.Manager

ExpressionManager with update preventing the update of non-notes

get_queryset()¶

log_action(request, conent_object, organization_id, action_response=None, action_note=None, audit_type=0)¶

use_for_related_fields = True¶

class seed.audit_logs.models.AuditLogQuerySet(model=None, query=None, using=None, hints=None)¶

Bases: django.db.models.query.QuerySet

update(*args, **kwargs)¶

only notes should be updated, so filter out non-notes

Tests¶

class seed.audit_logs.tests.AuditLogModelTests(methodName='runTest')¶

Bases: django.test.testcases.TestCase

setUp()¶

test_audit()¶

tests audit save

test_audit_save()¶

audit_log LOG should not be able to save/update

test_audit_update()¶

audit_log LOG should not be able to save/update

test_generic_relation()¶

test CanonicalBuilding.audit_logs

test_get_all_audit_logs_for_an_org()¶

gets all audit logs for an org

test_model___unicode__()¶

tests the AuditLog inst. str or unicode

test_note()¶

tests note save

test_note_save()¶

notes should be able to save/update

class seed.audit_logs.tests.AuditLogViewTests(methodName='runTest')¶

Bases: django.test.testcases.TestCase

setUp()¶

test_create_note()¶

tests create_note

test_get_building_logs()¶

test the django view get_building_logs

test_update_note()¶

tests update_note

URLs¶

Views¶

seed.audit_logs.views.create_note(request, *args, **kwargs)¶

Retrieves logs for a building.

POST:	Expects the CanonicalBuildings’s id in the JSON payload as building_id. Expects an organization_id (to which project belongs) in the query string. Expects the action_note to be in the JSON payload as action_note

Returns:

'audit_log' : {
    'user': {
        'first_name': user's firstname,
        'last_name': user's last_name,
        'id': user's id,
        'email': user's email address
    },
    'id': audit log's id,
    'audit_type': 'Note',
    'created': DateTime,
    'modified': DateTime,
    'action': method triggering log entry,
    'action_response': response of action,
    'action_note': the note body
    'organization': {
        'name': name of org,
        'id': id of org
},
'status': 'success'

seed.audit_logs.views.get_building_logs(request, *args, **kwargs)¶

Retrieves logs for a building.

GET:	Expects the CanonicalBuildings’s id in the query string as building_id. Expects an organization_id (to which project belongs) in the query string.

Returns:

'audit_logs' : [
    {
        'user': {
            'first_name': user's firstname,
            'last_name': user's last_name,
            'id': user's id,
            'email': user's email address
        },
        'id': audit log's id,
        'audit_type': 'Log' or 'Note',
        'created': DateTime,
        'modified': DateTime,
        'action': method triggering log entry,
        'action_response': response of action,
        'action_note': the note body if Note or further description
        'organization': {
            'name': name of org,
            'id': id of org
        }
    }, ...
],
'status': 'success'

seed.audit_logs.views.update_note(request, *args, **kwargs)¶

Retrieves logs for a building.

PUT:	Expects the CanonicalBuildings’s id in the JSON payload as building_id. Expects an organization_id (to which project belongs) in the query string. Expects the action_note to be in the JSON payload as action_note Expects the audit_log_id to be in the JSON payload as audit_log_id

Returns:

'audit_log' : {
    'user': {
        'first_name': user's firstname,
        'last_name': user's last_name,
        'id': user's id,
        'email': user's email address
    },
    'id': audit log's id,
    'audit_type': 'Note',
    'created': DateTime,
    'modified': DateTime,
    'action': method triggering log entry,
    'action_response': response of action,
    'action_note': the note body
    'organization': {
        'name': name of org,
        'id': id of org
},
'status': 'success'

Inheritance¶

Submodules¶

Models¶

class seed.cleansing.models.Cleansing(organization, *args, **kwargs)¶

Bases: object

static cache_key(file_pk)¶

Static method to return the location of the cleansing results from redis.

Parameters:	file_pk – Import file primary key
Returns:

cleanse(record_type, data)¶

Send in data as a queryset from the BuildingSnapshot ids. :param record_type: one of property/taxlot :param data: rows of data to be cleansed :return:

data_type_check(datum)¶

Check the data types of the fields. These should never be wrong as these are the data in the database.

This chunk of code is currently ignored.

Parameters:	datum – Database record containing the BS version of the fields populated
Returns:	None

get_fieldnames(record_type)¶

Get fieldnames to apply to results.

in_range_checking(datum)¶

Check for errors in the min/max of the values.

Parameters:	datum – Database record containing the BS version of the fields populated
Returns:	None

static initialize_cache(file_pk)¶

Initialize the cache for storing the results. This is called before the celery tasks are chunked up.

Parameters:	file_pk – Import file primary key
Returns:

missing_matching_field(datum)¶

Look for fields in the database that are not matched. Missing is defined as a None in the database

Parameters:	datum – Database record containing the BS version of the fields populated
Returns:	None

# TODO: NL: Should we check the extra_data field for the data?

missing_values(datum)¶

Look for fields in the database that are empty. Need to know the list of fields that are part of the cleansing section.

The original intent of this method would be very intensive to run (looking at all fields except the ignored). This method was changed to check for required values.

Parameters:	datum – Database record containing the BS version of the fields populated
Returns:	None

# TODO: Check the extra_data field for the data?

prune_data()¶

Prune the results will remove any entries that have zero cleansing_results

Returns:	None

reset_results()¶

save_to_cache(file_pk)¶

Save the results to the cache database. The data in the cache are stored as a list of dictionaries. The data in this class are stored as a dict of dict. This is important to remember because the data from the cache cannot be simply loaded into the above structure.

Parameters:	file_pk – Import file primary key
Returns:	None

class seed.cleansing.models.Rules(id, org, field, enabled, category, type, min, max, severity, units)¶

Bases: django.db.models.base.Model

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception Rules.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

static Rules.delete_rules(organization)¶

Rules.get_category_display(*moreargs, **morekwargs)¶

Rules.get_severity_display(*moreargs, **morekwargs)¶

Rules.get_type_display(*moreargs, **morekwargs)¶

static Rules.initialize_rules(organization)¶

Rules.objects = <django.db.models.manager.Manager object>¶

Rules.org¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

static Rules.restore_defaults(organization)¶

Tasks¶

Tests¶

class seed.cleansing.tests.CleansingDataSample(methodName='runTest')¶

Bases: django.test.testcases.TestCase

setUp()¶

test_cleanse()¶

class seed.cleansing.tests.CleansingDataTestCoveredBuilding(methodName='runTest')¶

Bases: django.test.testcases.TestCase

setUp()¶

test_cleanse(*args, **kwargs)¶

test_simple_login()¶

class seed.cleansing.tests.CleansingDataTestPM(methodName='runTest')¶

Bases: django.test.testcases.TestCase

setUp()¶

test_cleanse()¶

class seed.cleansing.tests.CleansingViewTests(methodName='runTest')¶

Bases: django.test.testcases.TestCase

setUp()¶

test_get_cleansing_results()¶

test_get_csv()¶

test_get_progress()¶

URLs¶

Views¶

Submodules¶

Mapper¶

Util¶

seed.common.util.apply_map(map_path, data_path, out_file)¶

Apply a JSON mapping to data, and write the output.

Args:

map_path (str): Path to mapping file data_path (str): Path to data file out_file (file): output stream

Return:

None

seed.common.util.create_map(path_in, path_out)¶

Create a JSON mapping file, suitable for map.Mapping(), from a CSV input file in our own custom style.

Input columns: CurrentSEED,NewSEED,PM1,PM2,Type (ignore rest)

Parameters:	path_in – path_out –
Returns:	None

seed.common.util.find_duplicates(map_path, data_path, out_file)¶

Find duplicates created by a given mapping on a given input file.

Args:

map_path (str): Path to mapping file data_path (str): Path to data file out_file (file): output stream

Return:

None

Views¶

seed.common.views.api_error(reason)¶

JSON response for API error.

seed.common.views.api_success(**kwargs)¶

JSON response for API success.

seed.common.views.missing_request_keys(keys, body)¶

Check for keys in body.

Args:

keys (list): List of keys to check body (dict): body of request

Returns:

None if all present, JSON error response (using api_error()) if one or more is missing.

seed.common.views.typeof_request_values(types, body)¶

Check for type of request values.

All keys in types are present in body.

Parameters:	types (dict) – key to type map, where type is a function used to test the type conversion. It should take one argument, the value, and raise a ValueError if it is invalid. body (dict) – body of request
Returns:	JSON

Example:

None if all OK, JSON error response (using `api_error()`)
if one or more is of the wrong type.

Submodules¶

Storage¶

class config.storage.CachedS3BotoStorage(*args, **kwargs)¶

Bases: storages.backends.s3boto.S3BotoStorage

S3 storage backend that saves the files locally, too.

save(name, content)¶

Template Context¶

config.template_context.sentry_js(request)¶

config.template_context.session_key(request)¶

Tests¶

Utils¶

config.utils.de_camel_case(name)¶

Views¶

config.views.robots_txt(request, allow=False)¶

WSGI¶

WSGI config for config project.

This module contains the WSGI application used by Django’s development server and any production WSGI deployments. It should expose a module-level variable named application. Django’s runserver and runfcgi commands discover this application via the WSGI_APPLICATION setting.

Usually you will have the standard Django WSGI application here, but it also might make sense to replace the whole Django WSGI application with a custom one that later delegates to the Django one. For example, you could introduce WSGI middleware here, or combine a Django application with an application of another framework.

Submodules¶

BEDES¶

Module contents¶

Submodules¶

Managers¶

class seed.data_importer.managers.NotDeletedManager¶

Bases: django.db.models.manager.Manager

get_queryset(*args, **kwargs)¶

use_for_related_fields = True¶

Models¶

URLs¶

Utils¶

class seed.data_importer.utils.CoercionRobot¶

Bases: object

lookup_hash(uncoerced_value, destination_model, destination_field)¶

make_key(value, model, field)¶

seed.data_importer.utils.acquire_lock(name, expiration=None)¶

Tries to acquire a lock from the cache. Also sets the lock’s value to the current time, allowing us to see how long it has been held.

Returns False if lock already belongs by another process.

seed.data_importer.utils.chunk_iterable(iter, chunk_size)¶

Breaks an iterable (e.g. list) into smaller chunks, returning a generator of the chunk.

seed.data_importer.utils.get_core_pk_column(table_column_mappings, primary_field)¶

seed.data_importer.utils.get_lock_time(name)¶

Examines a lock to see when it was acquired.

seed.data_importer.utils.release_lock(name)¶

Frees a lock.

Views¶

class seed.data_importer.views.LocalUploaderViewSet(**kwargs)

Bases: rest_framework.viewsets.GenericViewSet

Endpoint to upload data files to, if uploading to local file storage. Valid source_type values are found in seed.models.SEED_DATA_SOURCES

Returns:

{
    'success': True,
    'import_file_id': The ID of the newly-uploaded ImportFile
}

create(request, *args, **kwargs)

Upload a new file to an import_record. This is a multipart/form upload. — parameters:

• name: import_record description: the ID of the ImportRecord to associate this file with. required: true paramType: body
• name: source_type description: the type of file (e.g. ‘Portfolio Raw’ or ‘Assessed Raw’) required: false paramType: body
• name: source_program_version description: the version of the file as related to the source_type required: false paramType: body
• name: file or qqfile description: In-memory file object required: true paramType: Multipart

suffix = None

Module contents¶

Submodules¶

Module contents¶

Subpackages¶

Submodules¶

seed.green_button.xml_importer module¶

seed.green_button.xml_importer.as_collection(val)¶

Takes a value, returns that value if it is not a string and is an Iterable, and returns a list containing that value if it is not an Iterable or if it is a string. Returns None when val is None.

Parameters:	val – any value
Returns:	list containing val or val if it is Iterable and not a string.

seed.green_button.xml_importer.building_data(xml_data)¶

Extracts information about a building from a Green Button XML file.

Parameters:	xml_data – dictionary returned by xmltodict.parse when called on the contents of a Green Button XML file
Returns:	dictionary

• building information for a Green Button XML file
• information describing the meter used for collection
• list of time series meter reading data

seed.green_button.xml_importer.create_models(data, import_file)¶

Create a BuildingSnapshot, a CanonicalBuilding, and a Meter. Then, create TimeSeries models for each meter reading in data.

Parameters:	data – dictionary of building data from a Green Button XML file in the form returned by xml_importer.building_data import_file – ImportFile referencing the original xml file; needed for linking to BuildingSnapshot and for determining super_organization
Returns:	the created CanonicalBuilding

seed.green_button.xml_importer.energy_type(service_category)¶

Returns the seed model energy type corresponding to the green button service category.

Parameters:	service_category – int that is a green button service_category (string args will be converted to integers)
Returns:	int in seed.models.ENERGY_TYPES

seed.green_button.xml_importer.energy_units(uom)¶

Returns the seed model energy unit corresponding to the green button uom.

Parameters:	uom – int that is the green button uom number corresponding to the energy units supported by the green button schema (string args will be converted to integers)
Returns:	int in seed.models.ENERGY_UNITS

seed.green_button.xml_importer.import_xml(import_file)¶

Given an import_file referencing a raw Green Button XML file, extracts building and time series information from the file and constructs required database models.

Parameters:	import_file – a seed.models.ImportFile instance representing a Green Button XML file that has been previously uploaded
Returns:	the created CanonicalBuilding Inst.

seed.green_button.xml_importer.interval_block_data(ib_xml_data)¶

Takes a dictionary containing the contents of an IntervalBlock node from a Green Button XML file and returns a dictionary containing the start_time of the time series collection, the duration of the collection, and a list of readings containing the time series data from a meter.

Parameters:	ib_xml_data – dictionary of the contents of an IntervalBlock from a Green Button XML file
Returns:	dictionary containing meta data about an entire collection period and a list of the specific meter readings

seed.green_button.xml_importer.interval_data(reading_xml_data)¶

Takes a dictionary representing the contents of an IntervalReading XML node and pulls out data for a single time series reading. The dictionary will be a sub-dictionary of the dictionary returned by xmltodict.parse when called on a Green Button XML file. Returns a flat dictionary containing the interval data.

Parameters:	reading_xml_data – dictionary of IntervalReading XML node content in format specified by the xmltodict library.
Returns:	dictionary representing a time series reading with keys ‘cost’, ‘value’, ‘start_time’, and ‘duration’.

seed.green_button.xml_importer.meter_data(raw_meter_meta)¶

Takes a dictionary representing the contents of the entry node in a Green Button XML file that specifies the meta data about the meter that was used to record time series data for that file. Returns a flat dictionary containing the meter meta data.

Parameters:	raw_meter_meta – dictionary of the contents of the meter specification entry node in a Green Button XML file
Returns:	dictionary containing information about a meter with keys ‘currency’, ‘power_of_ten_multiplier’, and ‘uom’

Module contents¶

Subpackages¶

Submodules¶

Forms¶

class seed.landing.forms.LoginForm(data=None, files=None, auto_id=u'id_%s', prefix=None, initial=None, error_class=<class 'django.forms.utils.ErrorList'>, label_suffix=None, empty_permitted=False, field_order=None)¶

Bases: django.forms.forms.Form

base_fields = OrderedDict([('email', <django.forms.fields.EmailField object>), ('password', <django.forms.fields.CharField object>)])¶

declared_fields = OrderedDict([('email', <django.forms.fields.EmailField object>), ('password', <django.forms.fields.CharField object>)])¶

media¶

Models¶

class seed.landing.models.SEEDUser(*args, **kwargs)¶

Bases: django.contrib.auth.base_user.AbstractBaseUser, django.contrib.auth.models.PermissionsMixin

An abstract base class implementing a fully featured User model with admin-compliant permissions.

Username, password and email are required. Other fields are optional.

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception SEEDUser.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

SEEDUser.REQUIRED_FIELDS = ['email']¶

SEEDUser.USERNAME_FIELD = 'username'¶

SEEDUser.auditlog_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.buildingsnapshot_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.columnmapping_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.cycle_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.default_building_detail_custom_columns¶

A placeholder class that provides a way to set the attribute on the model.

SEEDUser.default_custom_columns¶

A placeholder class that provides a way to set the attribute on the model.

SEEDUser.default_organization¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

SEEDUser.email_user(subject, message, from_email=None)¶

Sends an email to this User.

SEEDUser.generate_key()¶

Creates and sets an API key for this user. Adapted from tastypie:

https://github.com/toastdriven/django-tastypie/blob/master/tastypie/models.py#L47 # noqa

SEEDUser.get_absolute_url()¶

SEEDUser.get_full_name()¶

Returns the first_name plus the last_name, with a space in between.

SEEDUser.get_next_by_date_joined(*moreargs, **morekwargs)¶

SEEDUser.get_previous_by_date_joined(*moreargs, **morekwargs)¶

SEEDUser.get_short_name()¶

Returns the short name for the user.

SEEDUser.groups¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.importrecord_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.last_modified_user¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.logentry_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.modified_import_records¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.objects = <django.contrib.auth.models.UserManager object>¶

SEEDUser.organizationuser_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.orgs¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.project_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.projectbuilding_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.projectpropertyview_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.projecttaxlotview_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.save(*args, **kwargs)¶

Ensure that email and username are synced.

SEEDUser.user_agreement¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

SEEDUser.user_permissions¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

Tests¶

class seed.landing.tests.UserLoginTest(methodName='runTest')¶

Bases: django.test.testcases.TestCase

setUp()¶

test_simple_login()¶

Happy path login with no ToS.

test_tos_login()¶

Happy path login when there is a ToS.

URLs¶

Views¶

seed.landing.views.landing_page(request)¶

seed.landing.views.login_view(request)¶

Standard Django login, with additions:

Lowercase the login email (username) Check user has accepted ToS, if any.

seed.landing.views.password_reset(request)¶

seed.landing.views.password_reset_complete(request)¶

seed.landing.views.password_reset_confirm(request, uidb64=None, token=None)¶

seed.landing.views.password_reset_done(request)¶

seed.landing.views.password_set(request, uidb64=None, token=None)¶

seed.landing.views.signup(request, uidb64=None, token=None)¶

Module contents¶

Submodules¶

Exporter Module¶

class seed.lib.exporter.Exporter(export_id, export_name, export_type)¶

Class to handle the exporting of buildings

export(buildings, fields, row_cb)¶

The main method of export. Uses the export type defined by the initializer

Parameters:	buildings – Array of building ids to export fields – Array of fields to export row_cb – ID for row cache
Returns:

export_csv(qs, fields=[], cb=None)¶

export_xls(qs, fields=[], cb=None)¶

static fields_from_queryset(qs)¶

Creates a list of all accessible fields on a model based off of a queryset.

This method should not be here. It seems that is should be on the building snapshot model. Not moved yet because I am unsure if the qs argument is more than one data type (i.e. BuildingSnapshot and/or ?)

filename()¶

The expected file name based on the export_id, export_name, and export_type

Returns:	String of the expected filename

subdirectory()¶

Create and return the subdirectory

Returns:	String of the subdirectory

static subdirectory_from_export_id(export_id)¶

Return the subdirectory as constructed by the instance method.

Parameters:	export_id – The export ID
Returns:	String of the path to the exported file

tempfile = None¶

valid_export_type()¶

seed.lib.exporter.batch_qs(qs, batch_size=1000)¶

From: https://djangosnippets.org/snippets/1170/

Returns a (start, end, total, queryset) tuple for each batch in the given queryset.

Usage:

seed.lib.exporter.construct_obj_row(obj, fields)¶

Creates an exportable row of data from an object and a list of fields. Ignores nones and instances of the Django Manager object, replacing them with blank unicode strings.

seed.lib.exporter.get_field_name_from_model(field, model)¶

Takes a field name like “building_snapshot__state” and returns the verbose field name as set in django, to be used as the header in exported files.

Parameters:	field – qs –
Returns:

seed.lib.exporter.get_field_value_from_instance(field, obj)¶

Does some deep diving to find the right value given a string like “building_snapshot__state”

seed.lib.exporter.qs_to_rows(qs, fields)¶

Module contents¶

Submodules¶

seed.mappings.mapper module¶

seed.mappings.seed_mappings module¶

Module contents¶

Subpackages¶

Submodules¶

JSON¶

class seed.managers.json.JsonManager¶

Bases: django.db.models.manager.Manager

get_queryset()¶

class seed.managers.json.JsonQuerySet(model=None, query=None, using=None, hints=None)¶

Bases: django.db.models.query.QuerySet

PRIMARY = 'extra_data'¶

TABLE = 'seed_buildingsnapshot'¶

json_order_by(key, order_by, order_by_rev=False, unit=None)¶

Module contents¶

Submodules¶

AuditLog¶

Columns¶

class seed.models.columns.Column(*args, **kwargs)¶

Bases: django.db.models.base.Model

The name of a column for a given organization.

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception Column.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

Column.SOURCE_CHOICES = (('P', 'Property'), ('T', 'Taxlot'))¶

Column.SOURCE_CHOICES_MAP = {'P': 'property', 'T': 'taxlot'}¶

Column.SOURCE_PROPERTY = 'P'¶

Column.SOURCE_TAXLOT = 'T'¶

static Column.create_mappings(mappings, organization, user)¶

Create the mappings for an organization and a user based on a simple array of array object.

Args:

mappings: dictionary containing mapping information

mappings: [

{

‘from_field’: ‘eui’, ‘to_field’: ‘energy_use_intensity’, ‘to_table_name’: ‘property’,

}, {

‘from_field’: ‘eui’, ‘to_field’: ‘energy_use_intensity’, ‘to_table_name’: ‘property’,

}

]

organization: Organization object user: User object

Returns:

True (data are saved in the ColumnMapping table in the database)

Column.enum¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

Column.get_extra_data_source_display(*moreargs, **morekwargs)¶

Column.mapped_mappings¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

Column.objects = <django.db.models.manager.Manager object>¶

Column.organization¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

Column.raw_mappings¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

static Column.save_column_names(model_obj)¶

Save unique column names for extra_data in this organization.

Basically this is a record of all the extra_data keys we’ve ever seen for a particular organization.

Parameters:	model_obj – model_obj instance (either PropertyState or TaxLotState).

Column.unit¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

class seed.models.columns.ColumnMapping(*args, **kwargs)¶

Bases: django.db.models.base.Model

Stores previous user-defined column mapping.

We’ll pull from this when pulling from varied, dynamic source data to present the user with previous choices for that same field in subsequent data loads.

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception ColumnMapping.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

ColumnMapping.column_mapped¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

ColumnMapping.column_raw¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

static ColumnMapping.get_column_mappings(organization)¶

Returns dict of all the column mappings for an Organization’s given source type

Parameters:	organization – instance, Organization.
Returns:	dict, list of dict.

Use this when actually performing mapping between data sources, but only call it after all of the mappings have been saved to the ColumnMapping table.

static ColumnMapping.get_column_mappings_by_table_name(organization)¶

Breaks up the get_column_mappings into another layer to provide access by the table name as a key.

Parameters:	organization – instance, Organization
Returns:	dict

ColumnMapping.get_source_type_display(*moreargs, **morekwargs)¶

ColumnMapping.is_concatenated()¶

Returns True if the ColumnMapping represents the concatenation of imported column names; else returns False.

ColumnMapping.is_direct()¶

Returns True if the ColumnMapping is a direct mapping from imported column name to either a BEDES column or a previously imported column. Returns False if the ColumnMapping represents a concatenation.

ColumnMapping.objects = <django.db.models.manager.Manager object>¶

ColumnMapping.remove_duplicates(qs, m2m_type='column_raw')¶

Remove any other Column Mappings that use these columns.

Parameters:	qs – queryset of Column. These are the Columns in a M2M with this instance. m2m_type – str, the name of the field we’re comparing against. Defaults to ‘column_raw’.

ColumnMapping.save(*args, **kwargs)¶

Overrides default model save to eliminate duplicate mappings.

Warning

Other column mappings which have the same raw_columns in them will be removed!

ColumnMapping.super_organization¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

ColumnMapping.user¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

seed.models.columns.get_column_mapping(raw_column, organization, attr_name='column_mapped')¶

Find the ColumnMapping objects that exist in the database from a raw_column

Parameters:	raw_column – str, the column name of the raw data. organization – Organization inst. attr_name – str, name of attribute on ColumnMapping to pull out. whether we’re looking at a mapping from the perspective of a raw_column (like we do when creating a mapping), or mapped_column, (like when we’re applying that mapping). # TODO: Remove the use of this attr_name
Returns:	list of mapped items, float representation of confidence.

Cycles¶

class seed.models.cycles.Cycle(id, organization, user, name, start, end, created)¶

Bases: django.db.models.base.Model

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception Cycle.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

Cycle.get_next_by_created(*moreargs, **morekwargs)¶

Cycle.get_next_by_end(*moreargs, **morekwargs)¶

Cycle.get_next_by_start(*moreargs, **morekwargs)¶

Cycle.get_previous_by_created(*moreargs, **morekwargs)¶

Cycle.get_previous_by_end(*moreargs, **morekwargs)¶

Cycle.get_previous_by_start(*moreargs, **morekwargs)¶

Cycle.importfile_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

Cycle.objects = <django.db.models.manager.Manager object>¶

Cycle.organization¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

Cycle.propertyview_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

Cycle.taxlotproperty_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

Cycle.taxlotview_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

Cycle.user¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

Joins¶

class seed.models.joins.TaxLotProperty(id, property_view, taxlot_view, cycle, primary)¶

Bases: django.db.models.base.Model

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception TaxLotProperty.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

TaxLotProperty.cycle¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

TaxLotProperty.objects = <django.db.models.manager.Manager object>¶

TaxLotProperty.property_view¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

TaxLotProperty.taxlot_view¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

Generic Models¶

class seed.models.models.AttributeOption(*args, **kwargs)¶

Bases: django.db.models.base.Model

Holds a single conflicting value for a BuildingSnapshot attribute.

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception AttributeOption.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

AttributeOption.building_variant¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

AttributeOption.get_value_source_display(*moreargs, **morekwargs)¶

AttributeOption.objects = <django.db.models.manager.Manager object>¶

class seed.models.models.BuildingAttributeVariant(*args, **kwargs)¶

Bases: django.db.models.base.Model

Place to keep the options of BuildingSnapshot attribute variants.

When we want to select which source’s values should sit in the Canonical Building’s position, we need to draw from a set of options determined during the matching phase. We should only have one ‘Variant’ container per field_name, per snapshot.

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception BuildingAttributeVariant.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

BuildingAttributeVariant.building_snapshot¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

BuildingAttributeVariant.objects = <django.db.models.manager.Manager object>¶

BuildingAttributeVariant.options¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

class seed.models.models.Compliance(id, created, modified, compliance_type, start_date, end_date, deadline_date, project)¶

Bases: django_extensions.db.models.TimeStampedModel

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception Compliance.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

Compliance.get_compliance_type_display(*moreargs, **morekwargs)¶

Compliance.get_next_by_created(*moreargs, **morekwargs)¶

Compliance.get_next_by_modified(*moreargs, **morekwargs)¶

Compliance.get_previous_by_created(*moreargs, **morekwargs)¶

Compliance.get_previous_by_modified(*moreargs, **morekwargs)¶

Compliance.objects = <django.db.models.manager.Manager object>¶

Compliance.project¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

Compliance.to_dict()¶

class seed.models.models.CustomBuildingHeaders(*args, **kwargs)¶

Bases: django.db.models.base.Model

Specify custom building header mapping for display.

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception CustomBuildingHeaders.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

CustomBuildingHeaders.building_headers¶

A placeholder class that provides a way to set the attribute on the model.

CustomBuildingHeaders.objects = <seed.managers.json.JsonManager object>¶

CustomBuildingHeaders.super_organization¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

class seed.models.models.Enum(*args, **kwargs)¶

Bases: django.db.models.base.Model

Defines a set of enumerated types for a column.

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception Enum.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

Enum.column_set¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

Enum.enum_values¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

Enum.objects = <django.db.models.manager.Manager object>¶

class seed.models.models.EnumValue(*args, **kwargs)¶

Bases: django.db.models.base.Model

Individual Enumerated Type values.

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception EnumValue.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

EnumValue.objects = <django.db.models.manager.Manager object>¶

EnumValue.values¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

class seed.models.models.Meter(*args, **kwargs)¶

Bases: django.db.models.base.Model

Meter specific attributes.

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception Meter.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

Meter.building_snapshot¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

Meter.get_energy_type_display(*moreargs, **morekwargs)¶

Meter.get_energy_units_display(*moreargs, **morekwargs)¶

Meter.objects = <django.db.models.manager.Manager object>¶

Meter.timeseries_data¶

Accessor to the related objects manager on the reverse side of a many-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

parent.children is a ReverseManyToOneDescriptor instance.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

class seed.models.models.NonCanonicalProjectBuildings(*args, **kwargs)¶

Bases: django.db.models.base.Model

Holds a reference to all project buildings that do not point at a canonical building snapshot.

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception NonCanonicalProjectBuildings.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

NonCanonicalProjectBuildings.objects = <django.db.models.manager.Manager object>¶

NonCanonicalProjectBuildings.projectbuilding¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

class seed.models.models.StatusLabel(id, created, modified, name, color, super_organization)¶

Bases: django_extensions.db.models.TimeStampedModel

BLUE_CHOICE = 'blue'¶

COLOR_CHOICES = (('red', <django.utils.functional.__proxy__ object>), ('blue', <django.utils.functional.__proxy__ object>), ('light blue', <django.utils.functional.__proxy__ object>), ('green', <django.utils.functional.__proxy__ object>), ('white', <django.utils.functional.__proxy__ object>), ('orange', <django.utils.functional.__proxy__ object>), ('gray', <django.utils.functional.__proxy__ object>))¶

DEFAULT_LABELS = ['Residential', 'Non-Residential', 'Violation', 'Compliant', 'Missing Data', 'Questionable Report', 'Update Bldg Info', 'Call', 'Email', 'High EUI', 'Low EUI', 'Exempted', 'Extension', 'Change of Ownership']¶

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

StatusLabel.GRAY_CHOICE = 'gray'¶

StatusLabel.GREEN_CHOICE = 'green'¶

StatusLabel.LIGHT_BLUE_CHOICE = 'light blue'¶

exception StatusLabel.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

StatusLabel.ORANGE_CHOICE = 'orange'¶

StatusLabel.RED_CHOICE = 'red'¶

StatusLabel.WHITE_CHOICE = 'white'¶

StatusLabel.canonicalbuilding_set¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

StatusLabel.get_color_display(*moreargs, **morekwargs)¶

StatusLabel.get_next_by_created(*moreargs, **morekwargs)¶

StatusLabel.get_next_by_modified(*moreargs, **morekwargs)¶

StatusLabel.get_previous_by_created(*moreargs, **morekwargs)¶

StatusLabel.get_previous_by_modified(*moreargs, **morekwargs)¶

StatusLabel.objects = <django.db.models.manager.Manager object>¶

StatusLabel.property_set¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

StatusLabel.super_organization¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

StatusLabel.taxlot_set¶

Accessor to the related objects manager on the forward and reverse sides of a many-to-many relation.

In the example:

class Pizza(Model):
    toppings = ManyToManyField(Topping, related_name='pizzas')

pizza.toppings and topping.pizzas are ManyToManyDescriptor instances.

Most of the implementation is delegated to a dynamically defined manager class built by create_forward_many_to_many_manager() defined below.

StatusLabel.to_dict()¶

class seed.models.models.TimeSeries(*args, **kwargs)¶

Bases: django.db.models.base.Model

For storing energy use over time.

exception DoesNotExist¶

Bases: django.core.exceptions.ObjectDoesNotExist

exception TimeSeries.MultipleObjectsReturned¶

Bases: django.core.exceptions.MultipleObjectsReturned

TimeSeries.meter¶

Accessor to the related object on the forward side of a many-to-one or one-to-one relation.

In the example:

class Child(Model):
    parent = ForeignKey(Parent, related_name='children')

child.parent is a ForwardManyToOneDescriptor instance.

TimeSeries.objects = <django.db.models.manager.Manager object>¶