Python shake_event.ShakeEvent类代码示例

 def test_i18n(self):
     """See if internationalisation is working."""
     shake_id = '20120726022003'
     shake_event = ShakeEvent(shake_id, locale='id')
     shaking = shake_event.mmi_shaking(5)
     expected_shaking = 'Sedang'
     self.assertEqual(expected_shaking, shaking)

 def test_grid_file_path(self):
     """Test grid_file_path works using cached data."""
     expected_path = os.path.join(
         shakemap_extract_dir(), SHAKE_ID, 'grid.xml')
     shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
     grid_path = shake_event.grid_file_path()
     self.assertEquals(expected_path, grid_path)

 def testI18n(self):
     """See if internationalisation is working."""
     myShakeId = '20120726022003'
     myShakeEvent = ShakeEvent(myShakeId, theLocale='id')
     myShaking = myShakeEvent.mmiShaking(5)
     myExpectedShaking = 'Sedang'
     self.assertEqual(myExpectedShaking, myShaking)

    def testBearingToCardinal(self):
        """Test we can convert a bearing to a cardinal direction."""
        myShakeId = '20120726022003'
        myShakeEvent = ShakeEvent(myShakeId)

        # Ints should work
        myExpectedResult = 'SSE'
        myResult = myShakeEvent.bearingToCardinal(160)
        myMessage = ('Got:\n%s\nExpected:\n%s\n' %
                     (myResult, myExpectedResult))
        assert myResult == myExpectedResult, myMessage

        # Floats should work
        myExpectedResult = 'SW'
        myResult = myShakeEvent.bearingToCardinal(225.4)
        myMessage = ('Got:\n%s\nExpected:\n%s\n' %
                     (myResult, myExpectedResult))
        assert myResult == myExpectedResult, myMessage

        # non numeric data as input should return None
        myExpectedResult = None
        myResult = myShakeEvent.bearingToCardinal('foo')
        myMessage = ('Got:\n%s\nExpected:\n%s\n' %
                     (myResult, myExpectedResult))
        assert myResult == myExpectedResult, myMessage

    def test_sorted_impacted_cities(self):
        """Test getting impacted cities sorted by mmi then population."""
        shake_id = '20120726022003'
        shake_event = ShakeEvent(shake_id)
        table = shake_event.sorted_impacted_cities()

        file_path = unique_filename(
            prefix='test_sorted_impacted_cities',
            suffix='.txt',
            dir=temp_dir('test'))
        cities_file = file(file_path, 'w')
        cities_file.writelines(str(table))
        cities_file.close()
        table = str(table).replace(', \'', ',\n\'')
        table += '\n'

        fixture_path = os.path.join(
            data_dir(), 'tests', 'test_sorted_impacted_cities.txt')
        cities_file = file(fixture_path)
        expected_string = cities_file.read()
        cities_file.close()
        expected_string = expected_string.replace(', \'', ',\n\'')

        self.max_diff = None
        self.assertEqual(expected_string, table)

    def test_calculate_fatalities(self):
        """Test that we can calculate fatalities."""
        LOGGER.debug(QGIS_APP.showSettings())
        shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
        result, fatalities_html = shake_event.calculate_impacts()

        # Get the os environment INASAFE_WORK_DIR if it exists
        inasafe_work_dir = base_data_dir()

        expected_result = ('%s/shakemaps-extracted/20131105060809/impact'
                           '-nearest.tif') % inasafe_work_dir
        message = 'Got: %s, Expected: %s' % (result, expected_result)
        self.assertEqual(result, expected_result, message)

        expected_result = ('%s/shakemaps-extracted/20131105060809/impacts'
                           '.html') % inasafe_work_dir

        message = 'Got: %s, Expected: %s' % (fatalities_html, expected_result)
        self.assertEqual(fatalities_html, expected_result, message)

        expected_fatalities = {2: 0.0,
                               3: 0.0,
                               4: 0.000036387775168853676,
                               5: 0.0,
                               6: 0.0,
                               7: 0.0,
                               8: 0.0,
                               9: 0.0}
        message = 'Got: %s, Expected: %s' % (
            shake_event.fatality_counts, expected_fatalities)
        self.assertEqual(
            shake_event.fatality_counts, expected_fatalities, message)

    def test_bearing_to_cardinal(self):
        """Test we can convert a bearing to a cardinal direction."""
        shake_id = '20120726022003'
        shake_event = ShakeEvent(shake_id)

        # Ints should work
        expected_result = 'SSE'
        result = shake_event.bearing_to_cardinal(160)
        message = ('Got:\n%s\nExpected:\n%s\n' %
                   (result, expected_result))
        assert result == expected_result, message

        # Floats should work
        expected_result = 'SW'
        result = shake_event.bearing_to_cardinal(225.4)
        message = ('Got:\n%s\nExpected:\n%s\n' %
                   (result, expected_result))
        assert result == expected_result, message

        # non numeric data as input should return None
        expected_result = None
        result = shake_event.bearing_to_cardinal('foo')
        message = ('Got:\n%s\nExpected:\n%s\n' %
                   (result, expected_result))
        assert result == expected_result, message

 def test_i18n(self):
     """See if internationalisation is working."""
     working_dir = shakemap_extract_dir()
     shake_event = ShakeEvent(working_dir=working_dir, event_id=SHAKE_ID, locale="id", data_is_local_flag=True)
     shaking = shake_event.mmi_shaking(5)
     expected_shaking = "Sedang"
     self.assertEqual(expected_shaking, shaking)

 def test_render_map(self):
     """Test render_map function in shake_event."""
     working_dir = shakemap_extract_dir()
     shake_event = ShakeEvent(working_dir=working_dir, event_id=SHAKE_ID, data_is_local_flag=True)
     # Render Map
     shake_event.render_map()
     # There should be exist:
     # 1. SHAKE_ID-en.pdf
     # 2. SHAKE_ID-en.png
     # 3. SHAKE_ID-thumb-en.png
     # 4. SHAKE_ID-metadata-en.pickle
     # 5. mmi-cities.shp, shx, dbf, prj, qml
     # 6. mmi-contours-nearest.shp, shx, dbf, prj, qml
     # 7. city-search-boxes.shp, shx, dbf, prj, qml
     # 8. composer-template.qpt
     # 9. project.qgs
     target_dir = os.path.join(shakemap_extract_dir(), SHAKE_ID)
     shapefile_extension = ["shp", "shx", "dbf", "prj", "qml"]
     # 1
     pdf_path = os.path.join(target_dir, "%s-en.pdf" % SHAKE_ID)
     message = "PDF Report is not generated successfully in %s" % pdf_path
     self.assertTrue(os.path.exists(pdf_path), message)
     # 2
     png_path = os.path.join(target_dir, "%s-en.png" % SHAKE_ID)
     message = "PNG Report is not generated successfully in %s" % png_path
     self.assertTrue(os.path.exists(png_path), message)
     # 3
     thumbnail_path = os.path.join(target_dir, "%s-thumb-en.png" % SHAKE_ID)
     message = "PNG Thumbnail is not generated successfully in %s" % (thumbnail_path)
     self.assertTrue(os.path.exists(thumbnail_path), message)
     # 4
     metadata_path = os.path.join(target_dir, "%s-metadata-en.pickle" % SHAKE_ID)
     message = "Metadata file is not generated successfully in %s" % (metadata_path)
     self.assertTrue(os.path.exists(metadata_path), message)
     # 5. mmi-cities.shp, shx, dbf, prj, qml
     mmi_cities_path = os.path.join(target_dir, "mmi-cities.shp")
     for extension in shapefile_extension:
         file_path = mmi_cities_path.replace("shp", extension)
         message = "mmi-cities.%s is not generated successfully in %s" % (extension, file_path)
         self.assertTrue(os.path.exists(file_path), message)
     # 6. mmi-contours-nearest.shp, shx, dbf, prj, qml
     mmi_contours_path = os.path.join(target_dir, "mmi-contours-nearest.shp")
     for extension in shapefile_extension:
         file_path = mmi_contours_path.replace("shp", extension)
         message = ("mmi-contours-nearest.%s is not generated successfully in " "%s") % (extension, file_path)
         self.assertTrue(os.path.exists(file_path), message)
     # 7. city-search-boxes.shp, shx, dbf, prj, qml
     city_search_boxes_path = os.path.join(target_dir, "city-search-boxes.shp")
     for extension in shapefile_extension:
         file_path = city_search_boxes_path.replace("shp", extension)
         message = ("city-search-boxes.%s is not generated successfully in " "%s") % (extension, file_path)
         self.assertTrue(os.path.exists(file_path), message)
     # 8
     composer_template_path = os.path.join(target_dir, "composer-template.qpt")
     message = "Composer template file is not generated successfully in %s" % composer_template_path
     self.assertTrue(os.path.exists(composer_template_path), message)
     # 9
     qgs_project_path = os.path.join(target_dir, "project.qgs")
     message = "QGIS Project file is not generated successfully in %s" % (qgs_project_path)
     self.assertTrue(os.path.exists(qgs_project_path), message)

    def testCalculateFatalities(self):
        """Test that we can calculate fatalities."""
        LOGGER.debug(QGIS_APP.showSettings())
        myShakeId = '20120726022003'
        myShakeEvent = ShakeEvent(myShakeId)
        myResult, myFatalitiesHtml = myShakeEvent.calculateImpacts()

        myExpectedResult = (
            '/tmp/inasafe/realtime/shakemaps-extracted'
            '/20120726022003/impact-nearest.tif')
        myMessage = 'Got:\n%s\nExpected:\n%s\n' % (myResult, myExpectedResult)
        assert myResult == myExpectedResult, myMessage

        myExpectedResult = (
            '/tmp/inasafe/realtime/shakemaps-extracted'
            '/20120726022003/impacts.html')

        myMessage = 'Got:\n%s\nExpected:\n%s\n' % (
            myFatalitiesHtml,
            myExpectedResult)
        assert myFatalitiesHtml == myExpectedResult, myMessage

        myExpectedFatalities = {2: 0.0,  # rounded from 0.47386375223673427,
                                3: 0.0,  # rounded from 0.024892573693488258,
                                4: 0.0,
                                5: 0.0,
                                6: 0.0,
                                7: 0.0,
                                8: 0.0,
                                9: 0.0}

        myMessage = 'Got:\n%s\nExpected:\n%s\n' % (
            myShakeEvent.fatalityCounts, myExpectedFatalities)
        assert myShakeEvent.fatalityCounts == myExpectedFatalities, myMessage

    def test_bearing_to_cardinal(self):
        """Test we can convert a bearing to a cardinal direction."""
        working_dir = shakemap_extract_dir()
        shake_event = ShakeEvent(
            working_dir=working_dir,
            event_id=SHAKE_ID,
            data_is_local_flag=True)

        # Ints should work
        expected_result = 'SSE'
        result = shake_event.bearing_to_cardinal(160)
        message = ('Got:\n%s\nExpected:\n%s\n' %
                   (result, expected_result))
        self.assertEqual(result, expected_result, message)

        # Floats should work
        expected_result = 'SW'
        result = shake_event.bearing_to_cardinal(225.4)
        message = ('Got:\n%s\nExpected:\n%s\n' %
                   (result, expected_result))
        self.assertEqual(result, expected_result, message)

        # non numeric data as input should return None
        expected_result = None
        result = shake_event.bearing_to_cardinal('foo')
        message = ('Got:\n%s\nExpected:\n%s\n' %
                   (result, expected_result))
        self.assertEqual(result, expected_result, message)

 def test_event_info_dict(self):
     """Test we can get a dictionary of location info nicely."""
     shake_event = ShakeEvent(SHAKE_ID, data_is_local_flag=True)
     result = shake_event.event_dict()
     #noinspection PyUnresolvedReferences
     expected_dict = {
         'place-name': u'n/a',
         'depth-name': u'Depth',
         'fatalities-name': u'Estimated fatalities',
         'fatalities-count': u'0',  # 44 only after render
         'elapsed-time': u'',  # empty as it will change
         'legend-name': u'Population density',
         'fatalities-range': '0 - 100',
         'longitude-name': u'Longitude',
         'located-label': u'Located',
         'distance-unit': u'km',
         'bearing-compass': u'n/a',
         'elapsed-time-name': u'Elapsed time since event',
         'exposure-table-name': u'Estimated number of people '
                                u'affected by each MMI level',
         'longitude-value': u'140\xb037\'12.00"E',
         'city-table-name': u'Places Affected',
         'bearing-text': u'bearing',
         'limitations': (
             u'This impact estimation is automatically generated and only '
             u'takes into account the population and cities affected by '
             u'different levels of ground shaking. The estimate is based '
             u'on ground shaking data from BMKG, population density data '
             u'from asiapop.org, place information from geonames.org and '
             u'software developed by BNPB. Limitations in the estimates of '
             u'ground shaking, population  data and place names datasets '
             u'may result in significant misrepresentation of the '
             u'on-the-ground situation in the figures shown here. '
             u'Consequently decisions should not be made solely on the '
             u'information presented here and should always be verified by '
             u'ground truthing and other reliable information sources. The '
             u'fatality calculation assumes that no fatalities occur for '
             u'shake levels below MMI 4. Fatality counts of less than 50 '
             u'are disregarded.'),
         'depth-unit': u'km',
         'latitude-name': u'Latitude',
         'mmi': '3.6',
         'map-name': u'Estimated Earthquake Impact',
         'date': '5-11-2013',
         'bearing-degrees': '0.00\xb0',
         'formatted-date-time': '05-Nov-13 06:08:09 ',
         'distance': '0.00',
         'direction-relation': u'of',
         'credits': (
             u'Supported by the Australia-Indonesia Facility for Disaster '
             u'Reduction, Geoscience Australia and the World Bank-GFDRR.'),
         'latitude-value': u'2\xb025\'48.00"S',
         'time': '6:8:9',
         'depth-value': '10.0'}
     result['elapsed-time'] = u''
     message = 'Got:\n%s\nExpected:\n%s\n' % (result, expected_dict)
     self.max_diff = None
     difference = DictDiffer(result, expected_dict)
     print difference.all()
     self.assertDictEqual(expected_dict, result, message)

    def test_event_parser(self):
        """Test eventFilePath works (using cached data)"""
        shake_id = '20120726022003'
        shake_event = ShakeEvent(shake_id)
        self.assertEquals(26, shake_event.day)
        self.assertEquals(7, shake_event.month)
        self.assertEquals(2012, shake_event.year)
        self.assertEquals(2, shake_event.hour)
        self.assertEquals(15, shake_event.minute)
        self.assertEquals(35, shake_event.second)
        self.assertEquals('WIB', shake_event.timezone)
        self.assertEquals(124.45, shake_event.longitude)
        self.assertEquals(-0.21, shake_event.latitude)
        self.assertEquals(11.0, shake_event.depth)
        self.assertEquals('Southern Molucca Sea', shake_event.location)
        self.assertEquals(122.45, shake_event.x_minimum)
        self.assertEquals(126.45, shake_event.x_maximum)
        self.assertEquals(-2.21, shake_event.y_minimum)
        self.assertEquals(1.79, shake_event.y_maximum)

        grid_xml_data = shake_event.mmi_data
        self.assertEquals(25921, len(grid_xml_data))

        delimited_string = shake_event.mmi_data_to_delimited_text()
        self.assertEqual(578234, len(delimited_string))

    def test_eventParser(self):
        """Test eventFilePath works (using cached data)"""
        myShakeId = '20120726022003'
        myShakeEvent = ShakeEvent(myShakeId)
        self.assertEquals(26, myShakeEvent.day)
        self.assertEquals(7, myShakeEvent.month)
        self.assertEquals(2012, myShakeEvent.year)
        self.assertEquals(2, myShakeEvent.hour)
        self.assertEquals(15, myShakeEvent.minute)
        self.assertEquals(35, myShakeEvent.second)
        self.assertEquals('WIB', myShakeEvent.timeZone)
        self.assertEquals(124.45, myShakeEvent.longitude)
        self.assertEquals(-0.21, myShakeEvent.latitude)
        self.assertEquals(11.0, myShakeEvent.depth)
        self.assertEquals('Southern Molucca Sea', myShakeEvent.location)
        self.assertEquals(122.45, myShakeEvent.xMinimum)
        self.assertEquals(126.45, myShakeEvent.xMaximum)
        self.assertEquals(-2.21, myShakeEvent.yMinimum)
        self.assertEquals(1.79, myShakeEvent.yMaximum)

        myGridXmlData = myShakeEvent.mmiData
        self.assertEquals(25921, len(myGridXmlData))

        myDelimitedString = myShakeEvent.mmiDataToDelimitedText()
        self.assertEqual(578234, len(myDelimitedString))

    def testSortedImpactedCities(self):
        """Test getting impacted cities sorted by mmi then population."""
        myShakeId = '20120726022003'
        myShakeEvent = ShakeEvent(myShakeId)
        myTable = myShakeEvent.sortedImpactedCities()

        myFilePath = unique_filename(
            prefix='testSortedImpactedCities',
            suffix='.txt',
            dir=temp_dir('test'))
        myFile = file(myFilePath, 'wt')
        myFile.writelines(str(myTable))
        myFile.close()
        myTable = str(myTable).replace(', \'', ',\n\'')
        myTable += '\n'

        myFixturePath = os.path.join(
            dataDir(), 'tests', 'testSortedImpactedCities.txt')
        myFile = file(myFixturePath, 'rt')
        myExpectedString = myFile.read()
        myFile.close()
        myExpectedString = myExpectedString.replace(', \'', ',\n\'')

        self.maxDiff = None
        self.assertEqual(myExpectedString, myTable)