def __init__(self, args):
Config.interface = args.interface
Config.auth_token = args.auth_token
Config.summary = args.summary
Config.censor = Censor(args.censor)
if args.mac_vendors:
Config.mac = Mac(args.mac_vendors)
def test_censor():
try:
file_path = __get_file('/../data/testing.wav')
audio_segment = AudioSegment.from_file(file_path)
# Duplicate the audio file and begin muting the new file
file_path_dup = __get_file('/../data/testing-censored-0.wav')
dup_file = audio_segment.export(file_path_dup, format='wav')
audio_segment_dup = AudioSegment.from_file(file_path_dup)
# Test that the explicits were successfully removed
wrapper = ChunkWrapper(audio_segment_dup)
location = str(Path(__file__).parents[2]) + '/clean_file.wav'
audio_segment_dup = Censor(explicits, 'wav',
location)._Censor__mute_explicits(
file_path_dup, wrapper,
timestamps).segment
# Get the silence segments
silent_ranges = silence.detect_silence(audio_segment_dup,
min_silence_len=500,
silence_thresh=-50)
# Assert silence is only in the 'mute' timestamp
assert len(silent_ranges) == 1
beginning_diff = silent_ranges[0][0] - timestamps[2]['start']
end_diff = silent_ranges[0][1] - timestamps[2]['end']
# Less than 5 (milliseconds) to account for small inaccuracies
assert abs(beginning_diff) < 5
assert abs(end_diff) < 5
except:
assert False
finally:
# Cleanup
os.remove(file_path_dup)
def test_censor(self):
c = Censor()
target = (
"Jan 13 01:08:40 localhost postfix/smtp[123]: "
"0A0000123B: to=<*****@*****.**>, "
"relay=mail.example.com[192.0.2.222]:25, delay=0.42, "
"delays=0.1/0/0.08/0.24, dsn=2.0.0, status=sent (250 ok)"
)
got = c.censor(target)
expected = (
"Jan 13 01:08:40 localhost postfix/smtp[123]: "
"0A0000123B: to=<*****@*****.**>, "
"relay=mail.example.com[192.0.2.222]:25, delay=0.42, "
"delays=0.1/0/0.08/0.24, dsn=2.0.0, status=sent (250 ok)"
)
self.assertEqual(got, expected)
def setUp(self):
self._censor = Censor()
class TestCensorDefault(TestCase):
def setUp(self):
self._censor = Censor()
def tearDown(self):
self._censor = None
def test_init(self):
self.assertEquals(0, len(self._censor._keywords))
self.assertEquals(0, len(self._censor._patterns))
self.assertEquals('*',self._censor._mask)
def test_keyword_addition(self):
kw = 'shit'
self._censor.add_keyword(kw)
self.assertEqual(kw, self._censor._keywords[0])
def test_keyword_sorting(self):
kw1 = 'shit'
kw2 = 'bastard'
self._censor.add_keyword(kw1)
self._censor.add_keyword(kw2)
self.assertEqual(kw2, self._censor._keywords[0])
self.assertEqual(kw1, self._censor._keywords[1])
def test_pattern_addition(self):
pt = r'[0-9]+'
self._censor.add_pattern(pt)
self.assertEqual(pt, self._censor._patterns[0].pattern)
@unittest.expectedFailure
def test_none_keyword_exception(self):
self._censor.add_keyword(None)
@unittest.expectedFailure
def test_none_pattern_exception(self):
self._censor.add_pattern(None)
def test_censor(self):
self._censor.add_keyword('f**k')
self._censor.add_keyword('dick')
self._censor.add_keyword('mother-f****r')
self._censor.add_pattern(r'[0-9]+')
text_to_censor = '897546974 hello you f**k, how are you dick and mother-f****r? 125'
censored_expected = '********* hello you ****, how are you **** and *************? ***'
censored_actual = self._censor.censor(text_to_censor)
self.assertEqual(censored_expected, censored_actual)
from censor import Censor
print("Welcome to Censor.py. \nPlease enter your Censored Words File and your File to be censored below:")
censorDictionaryFile = input("Censored Words Filename: ")
adverseFile = input("File to be censored Filename: ")
c = Censor()
c.input_badwords(censorDictionaryFile)
c.output_badwords('test.badwords')
c.addwords(['recently', 'badword2', 'remove_word'])
c.remove_words(['remove_word'])
c.censor_file(adverseFile)
class TestCensorDefault(unittest.TestCase):
def setUp(self):
self._censor = Censor()
def tearDown(self):
self._censor = None
def test_init(self):
self.assertEquals(0, len(self._censor._keywords))
self.assertEquals(0, len(self._censor._patterns))
self.assertEquals('*', self._censor._mask)
def test_keyword_addition(self):
kw = 'shit'
self._censor.add_keyword(kw)
self.assertEqual(kw, self._censor._keywords[0].pattern)
def test_keywords_addition(self):
kws = ['shit', 'ass', 'turd']
self._censor.add_keywords(kws)
for kw in self._censor._keywords:
self.assertIn(kw.pattern, kws)
def test_keyword_sorting(self):
kw1 = 'shit'
kw2 = 'bastard'
self._censor.add_keyword(kw1)
self._censor.add_keyword(kw2)
self.assertEqual(kw2, self._censor._keywords[0].pattern)
self.assertEqual(kw1, self._censor._keywords[1].pattern)
def test_pattern_addition(self):
pt = r'[0-9]+'
self._censor.add_pattern(pt)
self.assertEqual(pt, self._censor._patterns[0].pattern)
def test_none_keyword_exception(self):
self.assertRaises(NoKeywordProvidedError, self._censor.add_keyword, None)
def test_bad_keyword_exception(self):
self.assertRaises(BadKeywordProvidedError, self._censor.add_keyword, 0.1)
def test_none_keywords_exception(self):
self.assertRaises(NonIterableKeywordsError, self._censor.add_keywords, None)
def test_wrong_keywords_exception(self):
self.assertRaises(NonIterableKeywordsError, self._censor.add_keywords, 0.1)
def test_wrong_object_in_keywords_exception(self):
self.assertRaises(BadKeywordProvidedError, self._censor.add_keywords, ['shit', 0.1])
def test_none_pattern_exception(self):
self.assertRaises(NoPatternProvidedError, self._censor.add_pattern, None)
def test_censor(self):
self._censor.add_keyword('f**k')
self._censor.add_keyword('dick')
self._censor.add_keyword('mother-f****r')
self._censor.add_pattern(r'[0-9]+')
text_to_censor = '897546974 hello you f**k, how are you dick and mother-f****r? 125'
censored_expected = '********* hello you ****, how are you **** and *************? ***'
censored_actual = self._censor.censor(text_to_censor)
self.assertEqual(censored_expected, censored_actual)
def test_censor_invariant_case(self):
self._censor.add_keyword('f**k')
self._censor.add_keyword('sex')
text_to_censor = 'F**k you! I will not have sEx now.'
censored_expected = '**** you! I will not have *** now.'
censored_actual = self._censor.censor(text_to_censor)
self.assertEquals(censored_expected, censored_actual)
def censored_wigle_thread(device, ap):
brand = Censor.brand(device.get_brand())
str_ = ''
if brand:
str_ = '{} ({}) -> {}'.format(Censor.mac(device.mac_address), brand,
Censor.ssid(ap.ssid))
else:
str_ = '{} -> {}'.format(device.mac_address, ap.ssid)
wigle_data = ap.get_wigle_data() # this could take a while
if not wigle_data:
print(str_)
return
str_ += ' ({} results)'.format(wigle_data['resultCount'])
print(str_)
results = wigle_data['results']
for result in results:
str_ = '\t{},{}: '.format(Censor.gps(result['trilat']),
Censor.gps(result['trilong']))
country = Censor.country(result["country"])
region = Censor.region(result["region"])
city = Censor.city(result["city"])
postalcode = Censor.postalcode(result["postalcode"])
street = Censor.road(result["road"])
house_number = Censor.housenumber(result["housenumber"])
last_update = result["lastupdt"]
str_ += '{} - {} - {} - {} - {} - {} ({})'.format(
country, region, city, postalcode, street, house_number,
last_update)
print(str_)
