Пример #1
0
    def test_input2(self):
        storage = StorageFactory().get_storage('dict_storage')

        storage.write_table(table_name='buildings',
                            table_data={
                                        'building_id'        :array([ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12]),
                                        'zone_id'    :array([11,11,21,21,31,31,11,11,21,21,31,31]),
                                        'building_type_id' :array([ 7,99, 7,99, 7,99, 0,99, 0, 7,99, 7]),
                                        'tenure' :array([ 1,1, 2,2, 1,2, 1,1, 2, 2,2, 1]),
                                        }
                            ) 

        ds = DatasetFactory().get_dataset('submarket',
                                          package='bayarea',
                                          arguments={'in_storage':storage}
                                          )
        
        self.assertEqual(ds.get_id_name(), ['submarket_id'])
        self.assertTrue( "zone_id" in ds.get_known_attribute_names())
        self.assertArraysEqual( ds["zone_id"], array([11,11,11,21,21,21,31,31]))
        self.assertTrue( "building_type_id" in ds.get_known_attribute_names())
        self.assertArraysEqual( ds["building_type_id"], array([0,7,99,0,7,99,7,99]))
        self.assertEqual(ds.size(), 8)
        self.assertArraysEqual(ds.get_id_attribute(), array([11001, 
                                                             11071, 
                                                             11991, 
                                                             21002, 
                                                             21072, 
                                                             21992, 
                                                             31071, 
                                                             31992])
                                    )
    def test_input2(self):
        storage = StorageFactory().get_storage('dict_storage')
        
        storage.write_table(table_name='parcels',
                            table_data={
                                        'parcel_id'        :array([ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12]),
                                        'large_area_id'    :array([11,11,21,21,31,31,11,11,21,21,31,31]),
                                        'land_use_type_id' :array([ 7,99, 7,99, 7,99, 0,99, 0, 7,99, 7]),
                                        }
                            ) 

        ds = DatasetFactory().get_dataset('submarket',
                                          package='psrc_parcel',
                                          arguments={'in_storage':storage}
                                          )
        
        self.assertEqual(ds.get_id_name(), ['submarket_id'])
        self.assertTrue( "large_area_id" in ds.get_known_attribute_names())
        self.assertArraysEqual( ds["large_area_id"], array([11,11,11,21,21,21,31,31]))
        self.assertTrue( "land_use_type_id" in ds.get_known_attribute_names())
        self.assertArraysEqual( ds["land_use_type_id"], array([0,7,99,0,7,99,7,99]))
        self.assertEqual(ds.size(), 8)
        self.assertArraysEqual(ds.get_id_attribute(), array([
                                                       1100,
                                                       1107,
                                                       1199,
                                                       2100,
                                                       2107,
                                                       2199,
                                                       3107,
                                                       3199])
                                    )
Пример #3
0
 def test_input(self):
     storage = StorageFactory().get_storage('dict_storage')
     
     storage.write_table(table_name='districts',
                         table_data={
                                     'district_id'     :array([1,3,4]),
                                     }
                         ) 
     
     dc = DatasetFactory().get_dataset('district_commute',
                                       package='psrc_parcel',
                                       arguments={'in_storage':storage}
                                       )
     
     self.assertEqual(dc.get_id_name(), ['commute_id'])
     self.assertTrue( "origin_district_id" in dc.get_known_attribute_names())
     self.assertTrue( "destination_district_id" in dc.get_known_attribute_names())        
     self.assertEqual(dc.size(), 9)
     self.assertTrue(allclose(dc.get_id_attribute(), array([1001,
                                                    1003,
                                                    1004,
                                                    3001,
                                                    3003,
                                                    3004,
                                                    4001,
                                                    4003,
                                                    4004])
                                 ))
Пример #4
0
    def test_input2(self):
        storage = StorageFactory().get_storage('dict_storage')

        storage.write_table(
            table_name='parcels',
            table_data={
                'parcel_id':
                array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]),
                'large_area_id':
                array([11, 11, 21, 21, 31, 31, 11, 11, 21, 21, 31, 31]),
                'land_use_type_id':
                array([7, 99, 7, 99, 7, 99, 0, 99, 0, 7, 99, 7]),
            })

        ds = DatasetFactory().get_dataset('submarket',
                                          package='psrc_parcel',
                                          arguments={'in_storage': storage})

        self.assertEqual(ds.get_id_name(), ['submarket_id'])
        self.assertTrue("large_area_id" in ds.get_known_attribute_names())
        self.assertArraysEqual(ds["large_area_id"],
                               array([11, 11, 11, 21, 21, 21, 31, 31]))
        self.assertTrue("land_use_type_id" in ds.get_known_attribute_names())
        self.assertArraysEqual(ds["land_use_type_id"],
                               array([0, 7, 99, 0, 7, 99, 7, 99]))
        self.assertEqual(ds.size(), 8)
        self.assertArraysEqual(
            ds.get_id_attribute(),
            array([1100, 1107, 1199, 2100, 2107, 2199, 3107, 3199]))
Пример #5
0
    def test_input(self):
        storage = StorageFactory().get_storage('dict_storage')
        
        storage.write_table(table_name='fazes',
                            table_data={
                                        'faz_id'     :array([1,3,4]),
                                        }
                            ) 
        storage.write_table(table_name='households',
                            table_data={
                                        'household_id'  :array([1,2,3]),
                                        'persons'       :array([1,3,4]),
                                        }
                            )         

        dc = DatasetFactory().get_dataset('faz_persons',
                                          package='psrc_parcel',
                                          arguments={'in_storage':storage}
                                          )
        
        self.assertEqual(dc.get_id_name(), ['dummy_id'])
        self.assertTrue( "faz_id" in dc.get_known_attribute_names())
        self.assertTrue( "persons" in dc.get_known_attribute_names())        
        self.assertEqual(dc.size(), 9)
        self.assertTrue(allclose(dc.get_id_attribute(), array([
                                                       101,
                                                       103,
                                                       104,
                                                       301,
                                                       303,
                                                       304,
                                                       401,
                                                       403,
                                                       404])
                                    ))
Пример #6
0
    def test_input(self):
        storage = StorageFactory().get_storage('dict_storage')
        
        storage.write_table(table_name='fazes',
                            table_data={
                                        'faz_id'     :array([1,3,4]),
                                        }
                            ) 
        storage.write_table(table_name='households',
                            table_data={
                                        'household_id'  :array([1,2,3]),
                                        'persons'       :array([1,3,4]),
                                        }
                            )         

        dc = DatasetFactory().get_dataset('faz_persons',
                                          package='psrc_parcel',
                                          arguments={'in_storage':storage}
                                          )
        
        self.assertEqual(dc.get_id_name(), ['dummy_id'])
        self.assertTrue( "faz_id" in dc.get_known_attribute_names())
        self.assertTrue( "persons" in dc.get_known_attribute_names())        
        self.assertEqual(dc.size(), 9)
        self.assertTrue(allclose(dc.get_id_attribute(), array([
                                                       101,
                                                       103,
                                                       104,
                                                       301,
                                                       303,
                                                       304,
                                                       401,
                                                       403,
                                                       404])
                                    ))
    def test_input(self):
        storage = StorageFactory().get_storage("dict_storage")

        storage.write_table(table_name="districts", table_data={"district_id": array([1, 3, 4])})

        dc = DatasetFactory().get_dataset("district_commute", package="psrc_parcel", arguments={"in_storage": storage})

        self.assertEqual(dc.get_id_name(), ["commute_id"])
        self.assertTrue("origin_district_id" in dc.get_known_attribute_names())
        self.assertTrue("destination_district_id" in dc.get_known_attribute_names())
        self.assertEqual(dc.size(), 9)
        self.assertTrue(allclose(dc.get_id_attribute(), array([1001, 1003, 1004, 3001, 3003, 3004, 4001, 4003, 4004])))
    def test_input(self):
        storage = StorageFactory().get_storage('dict_storage')

        storage.write_table(table_name='districts',
                            table_data={
                                'district_id': array([1, 3, 4]),
                            })

        dc = DatasetFactory().get_dataset('district_commute',
                                          package='psrc_parcel',
                                          arguments={'in_storage': storage})

        self.assertEqual(dc.get_id_name(), ['commute_id'])
        self.assertTrue("origin_district_id" in dc.get_known_attribute_names())
        self.assertTrue(
            "destination_district_id" in dc.get_known_attribute_names())
        self.assertEqual(dc.size(), 9)
        self.assertTrue(
            allclose(
                dc.get_id_attribute(),
                array([1001, 1003, 1004, 3001, 3003, 3004, 4001, 4003, 4004])))
Пример #9
0
    def test_input(self):
        storage = StorageFactory().get_storage('dict_storage')
        
        storage.write_table(table_name='fazes',
                            table_data={
                                        'faz_id'     :array([1,3,4]),
                                        }
                            ) 
        storage.write_table(table_name='employment_sectors',
                            table_data={
                                        'sector_id'  :array([1,3,4]),
                                        }
                            )         
        storage.write_table(table_name='employment_adhoc_sector_group_definitions',
                            table_data={
                                        'sector_id'  :array([]),
                                        'group_id'   :array([]) 
                                        }
                            )         

        dc = DatasetFactory().get_dataset('faz_sector',
                                          package='psrc_parcel',
                                          arguments={'in_storage':storage}
                                          )
        
        self.assertEqual(dc.get_id_name(), ['dummy_id'])
        self.assertTrue( "faz_id" in dc.get_known_attribute_names())
        self.assertTrue( "sector_id" in dc.get_known_attribute_names())        
        self.assertEqual(dc.size(), 9)
        self.assertTrue(allclose(dc.get_id_attribute(), array([
                                                       101,
                                                       103,
                                                       104,
                                                       301,
                                                       303,
                                                       304,
                                                       401,
                                                       403,
                                                       404])
                                    ))
Пример #10
0
    def test_input(self):
        storage = StorageFactory().get_storage('dict_storage')
        
        storage.write_table(table_name='fazes',
                            table_data={
                                        'faz_id'     :array([1,3,4]),
                                        }
                            ) 
        storage.write_table(table_name='employment_sectors',
                            table_data={
                                        'sector_id'  :array([1,3,4]),
                                        }
                            )         
        storage.write_table(table_name='employment_adhoc_sector_group_definitions',
                            table_data={
                                        'sector_id'  :array([]),
                                        'group_id'   :array([]) 
                                        }
                            )         

        dc = DatasetFactory().get_dataset('faz_sector',
                                          package='psrc_parcel',
                                          arguments={'in_storage':storage}
                                          )
        
        self.assertEqual(dc.get_id_name(), ['dummy_id'])
        self.assertTrue( "faz_id" in dc.get_known_attribute_names())
        self.assertTrue( "sector_id" in dc.get_known_attribute_names())        
        self.assertEqual(dc.size(), 9)
        self.assertTrue(allclose(dc.get_id_attribute(), array([
                                                       101,
                                                       103,
                                                       104,
                                                       301,
                                                       303,
                                                       304,
                                                       401,
                                                       403,
                                                       404])
                                    ))
Пример #11
0
    def test_input2(self):
        storage = StorageFactory().get_storage("dict_storage")

        storage.write_table(
            table_name="buildings",
            table_data={
                "building_id": array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]),
                "zone_id": array([11, 11, 21, 21, 31, 31, 11, 11, 21, 21, 31, 31]),
                "building_type_id": array([7, 99, 7, 99, 7, 99, 0, 99, 0, 7, 99, 7]),
                "tenure": array([1, 1, 2, 2, 1, 2, 1, 1, 2, 2, 2, 1]),
            },
        )

        ds = DatasetFactory().get_dataset("submarket", package="bayarea", arguments={"in_storage": storage})

        self.assertEqual(ds.get_id_name(), ["submarket_id"])
        self.assertTrue("zone_id" in ds.get_known_attribute_names())
        self.assertArraysEqual(ds["zone_id"], array([11, 11, 11, 21, 21, 21, 31, 31]))
        self.assertTrue("building_type_id" in ds.get_known_attribute_names())
        self.assertArraysEqual(ds["building_type_id"], array([0, 7, 99, 0, 7, 99, 7, 99]))
        self.assertEqual(ds.size(), 8)
        self.assertArraysEqual(ds.get_id_attribute(), array([11001, 11071, 11991, 21002, 21072, 21992, 31071, 31992]))