def setUp(self):
        self.user = User.objects.create_user('john', '*****@*****.**',
                                             'johnpassword')

        self.project = create_project(spec={
            "project_id": uuid.uuid4(),
            "project_owner": self.user.projectowner,
            "baseline_period_end": datetime(2012, 1, 1, tzinfo=pytz.UTC),
            "reporting_period_start": datetime(2012, 2, 1, tzinfo=pytz.UTC),
            "zipcode": "91104",
            "traces": [
                {
                    "interpretation": "E_C_S",
                    "unit": "KWH",
                    "start": "2010-01-01",
                    "end": "2014-12-31",
                    "freq": "MS",
                    "value": 1,
                    "nans": set(range(0, 60, 20)),
                    "estimated": set(range(3, 60, 15)),
                },
            ],
        })
        self.project.run_meter()

        self.connection = Connection.create(projects=[self.project])

        self.client = Client()
Esempio n. 2
0
    def setUp(self):
        self.user = User.objects.create_user('john', '*****@*****.**',
                                             'johnpassword')

        self.project = create_project(
            spec={
                "project_id":
                uuid.uuid4(),
                "project_owner":
                self.user.projectowner,
                "baseline_period_end":
                datetime(2012, 1, 1, tzinfo=pytz.UTC),
                "reporting_period_start":
                datetime(2012, 2, 1, tzinfo=pytz.UTC),
                "zipcode":
                "91104",
                "traces": [
                    {
                        "interpretation": "E_C_S",
                        "unit": "KWH",
                        "start": "2010-01-01",
                        "end": "2014-12-31",
                        "freq": "MS",
                        "value": 1,
                        "nans": set(range(0, 60, 20)),
                        "estimated": set(range(3, 60, 15)),
                    },
                ],
            })
        self.project.run_meter()

        self.connection = Connection.create(projects=[self.project])

        self.client = Client()
    def setUp(self):
        self.user = User.objects.create_user('john', '*****@*****.**',
                                             'johnpassword')

        self.project = create_project(spec={
            "project_id": uuid.uuid4(),
            "project_owner": self.user.projectowner,
            "baseline_period_end": datetime(2012, 1, 1, tzinfo=pytz.UTC),
            "reporting_period_start": datetime(2012, 2, 1, tzinfo=pytz.UTC),
            "zipcode": "91104",
            "traces": [],
        })
    def setUp(self):
        user = User.objects.create_user('john', '*****@*****.**',
                                        'johnpassword')

        project = create_project(
            spec={
                "project_id":
                "CDEF",
                "project_owner":
                user.projectowner,
                "baseline_period_end":
                datetime(2012, 1, 1, tzinfo=pytz.UTC),
                "reporting_period_start":
                datetime(2012, 2, 1, tzinfo=pytz.UTC),
                "zipcode":
                "91104",
                "traces": [
                    {
                        "interpretation": "NG_C_S",
                        "unit": "THM",
                        "start": "2010-01-01",
                        "end": "2014-12-31",
                        "freq": "MS",
                        "value": 1,
                        "nans": set(range(0, 60, 20)),
                        "estimated": set(range(3, 60, 15)),
                    },
                    {
                        "interpretation": "E_C_S",
                        "unit": "KWH",
                        "start": "2011-01-01",
                        "end": "2014-12-31",
                        "freq": "D",
                        "value": 0.04,
                        "nans": set(range(0, 365 * 4, 20)),
                        "estimated": set(range(3, 365 * 4, 15)),
                    },
                    {
                        "interpretation": "E_OSG_U",
                        "unit": "KWH",
                        "start": "2010-01-01",
                        "end": "2014-12-31",
                        "freq": "D",
                        "value": 0.1,
                        "nans": set(range(0, 365 * 4, 20)),
                        "estimated": set(range(3, 365 * 4, 15)),
                    },
                ],
            })

        project_run = models.ProjectRun.objects.create(project=project)
        tasks.execute_project_run(project_run.pk)
    def setUp(self):
        self.user = User.objects.create_user('john', '*****@*****.**',
                                             'johnpassword')

        self.project = create_project(
            spec={
                "project_id": uuid.uuid4(),
                "project_owner": self.user.projectowner,
                "baseline_period_end": datetime(2012, 1, 1, tzinfo=pytz.UTC),
                "reporting_period_start": datetime(2012, 2, 1,
                                                   tzinfo=pytz.UTC),
                "zipcode": "91104",
                "traces": [],
            })
    def setUp(self):
        user = User.objects.create_user("john", "*****@*****.**", "johnpassword")

        project = create_project(
            spec={
                "project_id": "CDEF",
                "project_owner": user.projectowner,
                "baseline_period_end": datetime(2012, 1, 1, tzinfo=pytz.UTC),
                "reporting_period_start": datetime(2012, 2, 1, tzinfo=pytz.UTC),
                "zipcode": "91104",
                "traces": [
                    {
                        "interpretation": "NG_C_S",
                        "unit": "THM",
                        "start": "2010-01-01",
                        "end": "2014-12-31",
                        "freq": "MS",
                        "value": 1,
                        "nans": set(range(0, 60, 20)),
                        "estimated": set(range(3, 60, 15)),
                    },
                    {
                        "interpretation": "E_C_S",
                        "unit": "KWH",
                        "start": "2011-01-01",
                        "end": "2014-12-31",
                        "freq": "D",
                        "value": 0.04,
                        "nans": set(range(0, 365 * 4, 20)),
                        "estimated": set(range(3, 365 * 4, 15)),
                    },
                    {
                        "interpretation": "E_OSG_U",
                        "unit": "KWH",
                        "start": "2010-01-01",
                        "end": "2014-12-31",
                        "freq": "D",
                        "value": 0.1,
                        "nans": set(range(0, 365 * 4, 20)),
                        "estimated": set(range(3, 365 * 4, 15)),
                    },
                ],
            }
        )

        project_run = models.ProjectRun.objects.create(project=project)
        tasks.execute_project_run(project_run.pk)
    def test_with_projects(self):
        response = self.client.get(
            '/api/v1/registry/connections/',
            HTTP_AUTHORIZATION='Bearer tokstr')

        data = response.json()
        assert data == []

        project = create_project(spec={
            "project_id": uuid.uuid4(),
            "project_owner": self.user.projectowner,
            "baseline_period_end": datetime(2012, 1, 1, tzinfo=pytz.UTC),
            "reporting_period_start": datetime(2012, 2, 1, tzinfo=pytz.UTC),
            "zipcode": "91104",
            "traces": [],
        })

        response = self.client.post(
            '/api/v1/registry/connections/',
            data={
                'projects': [project.pk],
            },
            HTTP_AUTHORIZATION='Bearer tokstr')

        data = response.json()
        assert 'id' in data
        assert len(data['token']) == 36
        assert data['projects'] == [project.pk]

        response = self.client.get(
            '/api/v1/registry/connections/',
            HTTP_AUTHORIZATION='Bearer tokstr')

        data = response.json()[0]
        assert 'id' in data
        assert len(data['token']) == 36
        assert data['projects'] == [project.pk]
Esempio n. 8
0
    def test_with_projects(self):
        response = self.client.get('/api/v1/registry/connections/',
                                   HTTP_AUTHORIZATION='Bearer tokstr')

        data = response.json()
        assert data == []

        project = create_project(
            spec={
                "project_id": uuid.uuid4(),
                "project_owner": self.user.projectowner,
                "baseline_period_end": datetime(2012, 1, 1, tzinfo=pytz.UTC),
                "reporting_period_start": datetime(2012, 2, 1,
                                                   tzinfo=pytz.UTC),
                "zipcode": "91104",
                "traces": [],
            })

        response = self.client.post('/api/v1/registry/connections/',
                                    data={
                                        'projects': [project.pk],
                                    },
                                    HTTP_AUTHORIZATION='Bearer tokstr')

        data = response.json()
        assert 'id' in data
        assert len(data['token']) == 36
        assert data['projects'] == [project.pk]

        response = self.client.get('/api/v1/registry/connections/',
                                   HTTP_AUTHORIZATION='Bearer tokstr')

        data = response.json()[0]
        assert 'id' in data
        assert len(data['token']) == 36
        assert data['projects'] == [project.pk]
    def setUpTestData(cls):
        super(ProjectAPITestCase, cls).setUpTestData()

        cls.project = create_project(spec={
            "project_id": "BCDE",
            "project_owner": cls.project_owner,
            "baseline_period_end": datetime(2012, 1, 1, tzinfo=pytz.UTC),
            "reporting_period_start": datetime(2012, 2, 1, tzinfo=pytz.UTC),
            "zipcode": "91104",
            "traces": [
                {
                    "interpretation": "NG_C_S",
                    "unit": "THM",
                    "start": "2010-01-01",
                    "end": "2014-12-31",
                    "freq": "MS",
                    "value": 1,
                    "nans": set(range(0, 60, 20)),
                    "estimated": set(range(3, 60, 15)),
                },
                {
                    "interpretation": "NG_C_S",
                    "unit": "THM",
                    "start": "2011-09-01",
                    "end": "2014-12-31",
                    "freq": "D",
                    "value": 2,
                    "nans": set(range(0, 1000, 20)),
                    "estimated": set(range(3, 1000, 15)),
                },
                {
                    "interpretation": "E_C_S",
                    "unit": "KWH",
                    "start": "2011-01-01",
                    "end": "2014-12-31",
                    "freq": "15T",
                    "value": 0.04,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
                {
                    "interpretation": "E_C_S",
                    "unit": "KWH",
                    "start": "2011-01-01",
                    "end": "2014-12-31",
                    "freq": "H",
                    "value": 0.4,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
                {
                    "interpretation": "E_OSG_U",
                    "unit": "KWH",
                    "start": "2012-01-15",
                    "end": "2014-12-31",
                    "freq": "H",
                    "value": 0.3,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
                {
                    "interpretation": "E_OSG_U",
                    "unit": "KWH",
                    "start": "2010-01-01",
                    "end": "2014-12-31",
                    "freq": "30T",
                    "value": 0.1,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
            ],
        })
        cls.project.run_meter()
Esempio n. 10
0
    def handle(self, *args, **options):
        # create a superuser
        user = User.objects.create_superuser('demo', '*****@*****.**',
                                             'demo-password')
        user.save()

        app = ApplicationModel.objects.create(
            name='app',
            client_type=ApplicationModel.CLIENT_CONFIDENTIAL,
            authorization_grant_type=ApplicationModel.GRANT_CLIENT_CREDENTIALS,
            user=user
        )

        AccessToken.objects.create(
            user=user,
            token='tokstr',
            application=app,
            expires=now() + timedelta(days=365),
            scope="read write"
        )

        create_project(spec={
            "project_id": "ABC",
            "project_owner": user.projectowner,
            "baseline_period_end": datetime(2012, 1, 1, tzinfo=pytz.UTC),
            "reporting_period_start": datetime(2012, 2, 1, tzinfo=pytz.UTC),
            "zipcode": "91104",
            "traces": [
                {
                    "interpretation": "NG_C_S",
                    "unit": "THM",
                    "start": "2010-01-01",
                    "end": "2014-12-31",
                    "freq": "MS",
                    "value": 1,
                    "nans": set(range(0, 60, 20)),
                    "estimated": set(range(3, 60, 15)),
                },
                {
                    "interpretation": "NG_C_S",
                    "unit": "THM",
                    "start": "2011-09-01",
                    "end": "2014-12-31",
                    "freq": "D",
                    "value": 2,
                    "nans": set(range(0, 1000, 20)),
                    "estimated": set(range(3, 1000, 15)),
                },
                {
                    "interpretation": "E_C_S",
                    "unit": "KWH",
                    "start": "2011-01-01",
                    "end": "2014-12-31",
                    "freq": "15T",
                    "value": 0.04,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
                {
                    "interpretation": "E_C_S",
                    "unit": "KWH",
                    "start": "2011-01-01",
                    "end": "2014-12-31",
                    "freq": "H",
                    "value": 0.4,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
                {
                    "interpretation": "E_OSG_U",
                    "unit": "KWH",
                    "start": "2012-01-15",
                    "end": "2014-12-31",
                    "freq": "H",
                    "value": 0.3,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
                {
                    "interpretation": "E_OSG_U",
                    "unit": "KWH",
                    "start": "2010-01-01",
                    "end": "2014-12-31",
                    "freq": "30T",
                    "value": 0.1,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
            ],
        })
Esempio n. 11
0
    def handle(self, *args, **options):
        # create a superuser
        user = User.objects.create_superuser('demo', '*****@*****.**',
                                             'demo-password')
        user.save()

        app = ApplicationModel.objects.create(
            name='app',
            client_type=ApplicationModel.CLIENT_CONFIDENTIAL,
            authorization_grant_type=ApplicationModel.GRANT_CLIENT_CREDENTIALS,
            user=user)

        AccessToken.objects.create(user=user,
                                   token='tokstr',
                                   application=app,
                                   expires=now() + timedelta(days=365),
                                   scope="read write")

        create_project(
            spec={
                "project_id":
                "ABC",
                "project_owner":
                user.projectowner,
                "baseline_period_end":
                datetime(2012, 1, 1, tzinfo=pytz.UTC),
                "reporting_period_start":
                datetime(2012, 2, 1, tzinfo=pytz.UTC),
                "zipcode":
                "91104",
                "traces": [
                    {
                        "interpretation": "NG_C_S",
                        "unit": "THM",
                        "start": "2010-01-01",
                        "end": "2014-12-31",
                        "freq": "MS",
                        "value": 1,
                        "nans": set(range(0, 60, 20)),
                        "estimated": set(range(3, 60, 15)),
                    },
                    {
                        "interpretation": "NG_C_S",
                        "unit": "THM",
                        "start": "2011-09-01",
                        "end": "2014-12-31",
                        "freq": "D",
                        "value": 2,
                        "nans": set(range(0, 1000, 20)),
                        "estimated": set(range(3, 1000, 15)),
                    },
                    {
                        "interpretation": "E_C_S",
                        "unit": "KWH",
                        "start": "2011-01-01",
                        "end": "2014-12-31",
                        "freq": "15T",
                        "value": 0.04,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                    {
                        "interpretation": "E_C_S",
                        "unit": "KWH",
                        "start": "2011-01-01",
                        "end": "2014-12-31",
                        "freq": "H",
                        "value": 0.4,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                    {
                        "interpretation": "E_OSG_U",
                        "unit": "KWH",
                        "start": "2012-01-15",
                        "end": "2014-12-31",
                        "freq": "H",
                        "value": 0.3,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                    {
                        "interpretation": "E_OSG_U",
                        "unit": "KWH",
                        "start": "2010-01-01",
                        "end": "2014-12-31",
                        "freq": "30T",
                        "value": 0.1,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                ],
            })
    def setUpTestData(cls):

        cls.user = User.objects.create_user('john', '*****@*****.**',
                                            'johnpassword')

        cls.project = create_project(spec={
            "project_id": "ABCD",
            "project_owner": cls.user.projectowner,
            "baseline_period_end": datetime(2012, 1, 1, tzinfo=pytz.UTC),
            "reporting_period_start": datetime(2012, 2, 1, tzinfo=pytz.UTC),
            "zipcode": "91104",
            "traces": [
                {
                    "interpretation": "NG_C_S",
                    "unit": "THM",
                    "start": "2010-01-01",
                    "end": "2014-12-31",
                    "freq": "MS",
                    "value": 1,
                    "nans": set(range(0, 60, 20)),
                    "estimated": set(range(3, 60, 15)),
                },
                {
                    "interpretation": "NG_C_S",
                    "unit": "THM",
                    "start": "2011-09-01",
                    "end": "2014-12-31",
                    "freq": "D",
                    "value": 2,
                    "nans": set(range(0, 1000, 20)),
                    "estimated": set(range(3, 1000, 15)),
                },
                {
                    "interpretation": "E_C_S",
                    "unit": "KWH",
                    "start": "2011-01-01",
                    "end": "2014-12-31",
                    "freq": "15T",
                    "value": 0.04,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
                {
                    "interpretation": "E_C_S",
                    "unit": "KWH",
                    "start": "2011-01-01",
                    "end": "2014-12-31",
                    "freq": "H",
                    "value": 0.4,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
                {
                    "interpretation": "E_OSG_U",
                    "unit": "KWH",
                    "start": "2012-01-15",
                    "end": "2014-12-31",
                    "freq": "H",
                    "value": 0.3,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
                {
                    "interpretation": "E_OSG_U",
                    "unit": "KWH",
                    "start": "2010-01-01",
                    "end": "2014-12-31",
                    "freq": "30T",
                    "value": 0.1,
                    "nans": set(range(0, 96*365*4, 200)),
                    "estimated": set(range(3, 96*365*4, 150)),
                },
            ],
        })

        cls.project.run_meter()

        tmp_dir = tempfile.mkdtemp()
        wns = TMY3WeatherSource("724838", tmp_dir, preload=False)
        wns.client = MockWeatherClient()
        wns._load_data()
        cls.weather_normal_source = wns

        tmp_dir = tempfile.mkdtemp()
        ws = ISDWeatherSource("722880", tmp_dir)
        ws.client = MockWeatherClient()
        cls.weather_source = ws
Esempio n. 13
0
    def setUpTestData(cls):

        cls.user = User.objects.create_user('john', '*****@*****.**',
                                            'johnpassword')

        cls.project = create_project(
            spec={
                "project_id":
                "ABCD",
                "project_owner":
                cls.user.projectowner,
                "baseline_period_end":
                datetime(2012, 1, 1, tzinfo=pytz.UTC),
                "reporting_period_start":
                datetime(2012, 2, 1, tzinfo=pytz.UTC),
                "zipcode":
                "91104",
                "traces": [
                    {
                        "interpretation": "NG_C_S",
                        "unit": "THM",
                        "start": "2010-01-01",
                        "end": "2014-12-31",
                        "freq": "MS",
                        "value": 1,
                        "nans": set(range(0, 60, 20)),
                        "estimated": set(range(3, 60, 15)),
                    },
                    {
                        "interpretation": "NG_C_S",
                        "unit": "THM",
                        "start": "2011-09-01",
                        "end": "2014-12-31",
                        "freq": "D",
                        "value": 2,
                        "nans": set(range(0, 1000, 20)),
                        "estimated": set(range(3, 1000, 15)),
                    },
                    {
                        "interpretation": "E_C_S",
                        "unit": "KWH",
                        "start": "2011-01-01",
                        "end": "2014-12-31",
                        "freq": "15T",
                        "value": 0.04,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                    {
                        "interpretation": "E_C_S",
                        "unit": "KWH",
                        "start": "2011-01-01",
                        "end": "2014-12-31",
                        "freq": "H",
                        "value": 0.4,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                    {
                        "interpretation": "E_OSG_U",
                        "unit": "KWH",
                        "start": "2012-01-15",
                        "end": "2014-12-31",
                        "freq": "H",
                        "value": 0.3,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                    {
                        "interpretation": "E_OSG_U",
                        "unit": "KWH",
                        "start": "2010-01-01",
                        "end": "2014-12-31",
                        "freq": "30T",
                        "value": 0.1,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                ],
            })

        cls.project.run_meter()

        tmp_dir = tempfile.mkdtemp()
        wns = TMY3WeatherSource("724838", tmp_dir, preload=False)
        wns.client = MockWeatherClient()
        wns._load_data()
        cls.weather_normal_source = wns

        tmp_dir = tempfile.mkdtemp()
        ws = ISDWeatherSource("722880", tmp_dir)
        ws.client = MockWeatherClient()
        cls.weather_source = ws
Esempio n. 14
0
    def setUpTestData(cls):
        super(ProjectAPITestCase, cls).setUpTestData()

        cls.project = create_project(
            spec={
                "project_id":
                "BCDE",
                "project_owner":
                cls.project_owner,
                "baseline_period_end":
                datetime(2012, 1, 1, tzinfo=pytz.UTC),
                "reporting_period_start":
                datetime(2012, 2, 1, tzinfo=pytz.UTC),
                "zipcode":
                "91104",
                "traces": [
                    {
                        "interpretation": "NG_C_S",
                        "unit": "THM",
                        "start": "2010-01-01",
                        "end": "2014-12-31",
                        "freq": "MS",
                        "value": 1,
                        "nans": set(range(0, 60, 20)),
                        "estimated": set(range(3, 60, 15)),
                    },
                    {
                        "interpretation": "NG_C_S",
                        "unit": "THM",
                        "start": "2011-09-01",
                        "end": "2014-12-31",
                        "freq": "D",
                        "value": 2,
                        "nans": set(range(0, 1000, 20)),
                        "estimated": set(range(3, 1000, 15)),
                    },
                    {
                        "interpretation": "E_C_S",
                        "unit": "KWH",
                        "start": "2011-01-01",
                        "end": "2014-12-31",
                        "freq": "15T",
                        "value": 0.04,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                    {
                        "interpretation": "E_C_S",
                        "unit": "KWH",
                        "start": "2011-01-01",
                        "end": "2014-12-31",
                        "freq": "H",
                        "value": 0.4,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                    {
                        "interpretation": "E_OSG_U",
                        "unit": "KWH",
                        "start": "2012-01-15",
                        "end": "2014-12-31",
                        "freq": "H",
                        "value": 0.3,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                    {
                        "interpretation": "E_OSG_U",
                        "unit": "KWH",
                        "start": "2010-01-01",
                        "end": "2014-12-31",
                        "freq": "30T",
                        "value": 0.1,
                        "nans": set(range(0, 96 * 365 * 4, 200)),
                        "estimated": set(range(3, 96 * 365 * 4, 150)),
                    },
                ],
            })
        cls.project.run_meter()