followthemoney 1.3.7__py3-none-any.whl → 3.8.1__py3-none-any.whl

ns/ontology.py

@@ -1,128 +0,0 @@
-import sys
-import json
-from datetime import datetime
-from rdflib import Graph, Namespace, URIRef, Literal
-from rdflib.namespace import OWL, DCTERMS, RDF, RDFS, XSD
-
-from followthemoney import model, types
-
-
-class Ontology(object):
-
-    def __init__(self, ns_uri):
-
-        self.ns_uri = ns_uri
-        self.uri = URIRef(ns_uri)
-        self.ns = Namespace(ns_uri)
-
-        self.graph = Graph(identifier=ns_uri)
-        self.graph.namespace_manager.bind('ftm', self.ns)
-        self.graph.namespace_manager.bind('owl', OWL)
-        self.graph.namespace_manager.bind('dct', DCTERMS)
-
-        self.graph.add((self.uri, RDF.type, OWL.Ontology))
-        self.graph.add((self.uri, RDFS.label, Literal("Follow The Money")))
-        self.graph.add((self.uri, RDFS.comment, Literal(
-            "A vocabulary for investigative reporting, based on real life.")))
-        self.graph.add((self.uri, DCTERMS.modified,
-                        Literal(datetime.now().strftime('%Y-%m-%dT%H:%I:%M'), datatype=XSD.dateTime)))
-
-        self.add_schemata()
-
-    def uri_for(self, thing):
-        url = self.uri + thing.name  # Not using urljoin for this because it loses fragments
-        return URIRef(url)
-
-    def property_range(self, prop):
-        if prop.type == types.entities:
-            return self.uri_for(model[prop.range])
-        elif prop.type == types.dates:
-            return XSD.dateTime
-        return None
-
-    def add_class(self, entity):
-        entity_uri = self.uri_for(entity)
-        self.graph.add((entity_uri, RDF.type, RDFS.Class))
-        self.graph.add((entity_uri, RDFS.isDefinedBy, self.uri))
-        for extends in entity.extends:
-            self.graph.add((entity_uri, RDFS.subClassOf,
-                            self.uri_for(model[extends])))
-
-        self.graph.add((entity_uri, RDFS.label, Literal(entity.label)))
-        if entity.description is not None:
-            self.graph.add((entity_uri, RDFS.comment,
-                            Literal(entity.description)))
-
-    def add_property(self, entity, prop):
-        prop_uri = self.uri_for(prop)
-        self.graph.add((prop_uri, RDF.type, RDF.Property))
-        self.graph.add((prop_uri, RDFS.isDefinedBy, self.uri))
-
-        self.graph.add((prop_uri, RDFS.label, Literal(prop.label)))
-        if prop.description is not None:
-            self.graph.add((prop_uri, RDFS.comment, Literal(prop.description)))
-
-        self.graph.add((prop_uri, RDFS.domain, self.uri_for(entity)))
-        prop_range = self.property_range(prop)
-        if prop_range is not None:
-            self.graph.add((prop_uri, RDFS.range, prop_range))
-
-    def add_schemata(self):
-        for schema in model:
-            self.add_class(schema)
-            for prop in schema._own_properties:
-                self.add_property(schema, prop)
-
-    def serialize(self, format='n3'):
-        return self.graph.serialize(format=format)
-
-    def jsonld_context(self):
-        context = {
-            '@context': {
-                'xsd': 'http://www.w3.org/2001/XMLSchema#',
-                'ftm': self.ns_uri
-            }
-        }
-
-        for s, p, o in self.graph.triples((None, None, None)):
-            name = s.split(self.ns_uri)[1]
-            if name != "":
-                # id_types = ['entity', 'url', 'uri']
-                # if model.property_types.get(name) in id_types:
-                #     context['@context'][name] = {
-                #         '@id': 'ftm:%s' % name,
-                #         '@type': '@id'
-                #     }
-                # elif model.property_types.get(name) == 'date':
-                #     context['@context'][name] = {
-                #         '@id': 'ftm:%s' % name,
-                #         '@type': 'xsd:dateTime'
-                #     }
-                # else:
-                context['@context'][name] = 'ftm:%s' % name
-
-        return context
-
-    def write_namespace_docs(self, path):
-        ttl_fn = '%s/ftm.ttl' % path
-        with open(ttl_fn, 'w') as ttl_file:
-            ttl = self.serialize()
-            ttl_file.write(ttl.decode('utf-8'))
-
-        xml_fn = '%s/ftm.xml' % path
-        with open(xml_fn, 'w') as xml_file:
-            xml = self.serialize('xml')
-            xml_file.write(xml.decode('utf-8'))
-
-        json_fn = '%s/ftm.jsonld' % path
-        with open(json_fn, 'w') as json_file:
-            json_file.write(json.dumps(
-                self.jsonld_context(), indent=4, sort_keys=True))
-
-
-if __name__ == '__main__':
-    uri = sys.argv[1]
-    path = sys.argv[2]
-    o = Ontology(uri)
-    o.write_namespace_docs(path)
-    print("Namespace docs written to %s" % path)

tests/types/test_addresses.py

@@ -1,24 +0,0 @@
-import unittest
-
-from followthemoney.types import addresses
-
-UK = """43 Duke Street
-Edinburgh
-EH6 8HH"""
-
-
-class AddressesTest(unittest.TestCase):
-
-    def test_clean(self):
-        self.assertEqual(addresses.clean(UK),
-                         '43 Duke Street, Edinburgh, EH6 8HH')
-        self.assertEqual(addresses.clean('huhu\n   haha'), 'huhu, haha')
-        self.assertEqual(addresses.clean('huhu,\n haha'), 'huhu, haha')
-
-    def test_normalize(self):
-        self.assertEqual(addresses.normalize(UK), ['43 Duke Street, Edinburgh, EH6 8HH'])  # noqa
-        self.assertEqual(addresses.normalize('\n  '), [])
-
-    def test_specificity(self):
-        self.assertGreater(addresses.specificity(UK), 0.2)
-        self.assertLess(addresses.specificity('London'), 0.2)

tests/types/test_common.py

@@ -1,32 +0,0 @@
-import unittest
-
-from followthemoney.types import registry
-
-
-class CommonTest(unittest.TestCase):
-
-    def test_normalise_set(self):
-        t = registry.name
-        self.assertEqual(t.normalize_set(None), [])
-        self.assertEqual(t.normalize_set('boban'), ['boban'])
-        self.assertEqual(t.normalize_set(['boban']), ['boban'])
-
-    def test_ref(self):
-        t = registry.name
-        self.assertEqual(t.ref(''), None)
-        self.assertEqual(t.ref({'id': 'banana'}), 'n:banana')
-        self.assertEqual(t.ref('banana'), 'n:banana')
-        nt, v = registry.deref('n:banana')
-        self.assertEqual(v, 'banana')
-        self.assertEqual(t, nt)
-
-    def test_funcs(self):
-        t = registry.name
-        self.assertEqual(t.country_hint('banana'), None)
-        self.assertEqual(str(t), 'name')
-        self.assertEqual(hash(t), hash('name'))
-
-        self.assertGreater(t.compare_sets(['banana'], ['banana']), 0)
-        self.assertEqual(t.compare_sets(['banana'], []), 0)
-        self.assertIsNotNone(t.ref('banana'))
-        self.assertIsNone(registry.text.ref('banana'))

tests/types/test_countries.py

@@ -1,27 +0,0 @@
-import unittest
-
-from followthemoney.types import countries
-
-
-class CountriesTest(unittest.TestCase):
-
-    def test_country_codes(self):
-        self.assertEqual(countries.clean('DE'), 'de')
-        self.assertTrue(countries.validate('DE'))
-        self.assertFalse(countries.validate('DEU'))
-        self.assertFalse(countries.validate(''))
-        self.assertFalse(countries.validate(None))
-        self.assertFalse(countries.validate(4))
-        self.assertFalse(countries.validate('SU'))
-        self.assertTrue(countries.validate('XK'))
-        self.assertTrue(countries.validate('EU'))
-
-        self.assertEqual(countries.country_hint('eu'), 'eu')
-        assert 'iso-3166-1:eu' in countries.rdf('eu')
-
-    def test_country_names(self):
-        self.assertEqual(countries.clean(None), None)
-        self.assertEqual(countries.clean('Takatukaland', guess=False), None)
-        self.assertEqual(countries.clean('Germany'), 'de')
-        # self.assertEqual(countries.clean('Germani'), 'de')
-        self.assertEqual(countries.clean('Soviet Union'), 'suhh')

tests/types/test_dates.py

@@ -1,73 +0,0 @@
-# -*- coding: utf-8 -*-
-import unittest
-from datetime import datetime
-
-from followthemoney.types import dates
-
-
-class DatesTest(unittest.TestCase):
-
-    def test_validate(self):
-        self.assertTrue(dates.validate('2017-04-04T10:30:29'))
-        self.assertTrue(dates.validate('2017-04-04T10:30:29Z'))
-        self.assertTrue(dates.validate('2017-04-04T10:30:29+01'))
-        self.assertTrue(dates.validate('2017-04-04T10:30:29+0200'))
-        self.assertTrue(dates.validate('2017-04-04T10:30:29+03:00'))
-        self.assertTrue(dates.validate('2017-04-04T10:30:29-04:00'))
-        self.assertTrue(dates.validate(datetime.utcnow().isoformat()))
-        self.assertFalse(dates.validate('01-02-2003'))
-        self.assertFalse(dates.validate('Thursday 21 March 2017'))
-
-    def test_is_partial_date(self):
-        self.assertTrue(dates.validate('2017-04-04 10:30:29'))
-        self.assertTrue(dates.validate('2017-04-04 10:30'))
-        self.assertTrue(dates.validate('2017-04-04 10'))
-        self.assertTrue(dates.validate('2017-04-04'))
-        self.assertTrue(dates.validate('2017-4-4'))
-        self.assertTrue(dates.validate('2017-4'))
-        self.assertTrue(dates.validate('2017'))
-        self.assertFalse(dates.validate('0017'))
-        self.assertFalse(dates.validate(None))
-        self.assertFalse(dates.validate(5))
-        self.assertFalse(dates.validate('2017-20-01'))
-
-    def test_chop_dates(self):
-        self.assertEquals(dates.clean('2017-00-00'), '2017')
-        self.assertEquals(dates.clean('2017-00-00T00:00:00'), '2017')
-        self.assertEquals(dates.clean('2017-00-00T12:03:49'), '2017')
-        self.assertEquals(dates.clean('2017-01-01T00:00:00'), '2017-01-01')
-
-    def test_patch_dates(self):
-        self.assertEquals(dates.clean('2017-1-3'), '2017-01-03')
-        self.assertEquals(dates.clean('2017-3'), '2017-03')
-        self.assertEquals(dates.clean('2017-0'), '2017')
-        self.assertEquals(dates.clean('2017-5-2T00:00:00'), '2017-05-02')
-        self.assertEquals(dates.clean('2017-5-2T10:00:00'), '2017-05-02T10:00:00')  # noqa
-
-    def test_convert_datetime(self):
-        dt = datetime.utcnow()
-        iso, _ = dt.isoformat().split('.', 1)
-        self.assertEquals(dates.clean(dt), iso)
-        self.assertTrue(dates.validate(iso))
-
-        dt = datetime.utcnow().date()
-        iso = dt.isoformat()
-        self.assertEquals(dates.clean(dt), iso)
-
-    def test_parse_date(self):
-        self.assertEquals(dates.clean(None), None)
-        self.assertEquals(dates.clean(''), None)
-        self.assertEquals(dates.clean('banana'), None)
-        self.assertEquals(dates.clean('2017-04-04'), '2017-04-04')
-        self.assertEquals(dates.clean('2017-4-4'), '2017-04-04')
-
-        self.assertEquals(dates.clean('4/2017', format="%m/%Y"), '2017-04')
-        self.assertEquals(dates.clean('4/2017', format="4/%Y"), '2017')
-        self.assertEquals(dates.clean('4/2xx017', format="%m/%Y"), None)
-
-    def test_specificity(self):
-        self.assertEqual(dates.specificity('2011'), 0)
-        self.assertGreater(dates.specificity('2011-01-01'), 0.1)
-
-    def test_compare(self):
-        self.assertGreater(dates.compare('2011-01-01', '2011-01-01'), 0.9)

tests/types/test_domains.py

@@ -1,23 +0,0 @@
-import unittest
-
-from followthemoney.types import domains
-
-
-class DomainsTest(unittest.TestCase):
-
-    def test_parse(self):
-        self.assertEqual(domains.clean('pudo.org'), 'pudo.org')
-        self.assertEqual(domains.clean('pudoorg'), None)
-        self.assertEqual(domains.clean(None), None)
-        self.assertEqual(domains.clean('x.a'), None)
-
-    def test_normalize(self):
-        self.assertEqual(domains.normalize('PUDO'), [])
-        self.assertEqual(domains.normalize('PUDO.org'), ['pudo.org'])
-
-    def test_domain_validity(self):
-        self.assertTrue(domains.validate('pudo.org'))
-        self.assertFalse(domains.validate('pudo'))
-        self.assertFalse(domains.validate('x.a'))
-        self.assertFalse(domains.validate(''))
-        self.assertFalse(domains.validate('@pudo.org'))

tests/types/test_emails.py

@@ -1,32 +0,0 @@
-import unittest
-
-from followthemoney.types import emails
-
-
-class EmailsTest(unittest.TestCase):
-
-    def test_parse(self):
-        self.assertEqual(emails.clean('foo@pudo.org'), 'foo@pudo.org')
-        self.assertEqual(emails.clean('"foo@pudo.org"'), 'foo@pudo.org')
-        self.assertEqual(emails.clean('pudo.org'), None)
-        self.assertEqual(emails.clean('foo@'), None)
-        self.assertEqual(emails.clean(None), None)
-        self.assertEqual(emails.clean(5), None)
-        self.assertEqual(emails.clean('foo@PUDO.org'), 'foo@pudo.org')
-        self.assertEqual(emails.clean('FOO@PUDO.org'), 'FOO@pudo.org')
-
-    def test_normalize(self):
-        self.assertEqual(emails.normalize(None), [])
-        self.assertEqual(emails.normalize('FOO@PUDO'), [])
-        self.assertEqual(emails.normalize('FOO@PUDO.org'), ['foo@pudo.org'])
-
-    def test_domain_validity(self):
-        self.assertTrue(emails.validate('foo@pudo.org'))
-        self.assertFalse(emails.validate('foo@pudo'))
-        self.assertFalse(emails.validate(None))
-        self.assertFalse(emails.validate(''))
-        self.assertFalse(emails.validate('@pudo.org'))
-        self.assertFalse(emails.validate('foo@'))
-
-    def test_specificity(self):
-        self.assertEqual(emails.specificity('foo@pudo.org'), 1)

tests/types/test_entity.py

@@ -1,19 +0,0 @@
-import unittest
-
-from followthemoney.types import entities
-
-
-class EntityTest(unittest.TestCase):
-
-    def test_parse(self):
-        self.assertEqual(entities.clean('88'), '88')
-        self.assertEqual(entities.clean(88), '88')
-        self.assertEqual(entities.clean({'id': 88}), '88')
-        self.assertEqual(entities.clean(None), None)
-
-    def test_normalize(self):
-        self.assertEqual(entities.normalize('FOO'), ['FOO'])
-        self.assertEqual(entities.normalize(None), [])
-
-    def test_funcs(self):
-        self.assertEqual(entities.specificity('bla'), 1)

tests/types/test_iban.py

@@ -1,109 +0,0 @@
-import unittest
-
-from followthemoney.types import ibans
-
-
-class IbansTest(unittest.TestCase):
-
-    def test_parse(self):
-        self.assertEqual(ibans.clean('GB29 NWBK 6016 1331 9268 19'),
-                         'GB29NWBK60161331926819')
-
-    def test_domain_validity(self):
-        self.assertTrue(ibans.validate('GB29 NWBK 6016 1331 9268 19'))
-        self.assertTrue(ibans.validate('GB29NWBK60161331926819'))
-        self.assertFalse(ibans.validate('GB28 NWBK 6016 1331 9268 19'))
-        self.assertFalse(ibans.validate('GB29NWBKN0161331926819'))
-        self.assertFalse(ibans.validate(None))
-        self.assertTrue(ibans.validate('AL35202111090000000001234567'))
-        self.assertTrue(ibans.validate('AD1400080001001234567890'))
-        self.assertTrue(ibans.validate('AT483200000012345864'))
-        self.assertTrue(ibans.validate('AZ96AZEJ00000000001234567890'))
-        self.assertTrue(ibans.validate('BH02CITI00001077181611'))
-        # self.assertTrue(ibans.validate('BY86AKBB10100000002966000000'))
-        self.assertTrue(ibans.validate('BE71096123456769'))
-        self.assertTrue(ibans.validate('BA275680000123456789'))
-        self.assertTrue(ibans.validate('BR1500000000000010932840814P2'))
-        self.assertTrue(ibans.validate('BG18RZBB91550123456789'))
-        # self.assertTrue(ibans.validate('CR37012600000123456789'))
-        self.assertTrue(ibans.validate('HR1723600001101234565'))
-        self.assertTrue(ibans.validate('CY21002001950000357001234567'))
-        self.assertTrue(ibans.validate('CZ5508000000001234567899'))
-        self.assertTrue(ibans.validate('DK9520000123456789'))
-        self.assertTrue(ibans.validate('DO22ACAU00000000000123456789'))
-        # self.assertTrue(ibans.validate('SV43ACAT00000000000000123123'))
-        self.assertTrue(ibans.validate('EE471000001020145685'))
-        self.assertTrue(ibans.validate('FO9264600123456789'))
-        self.assertTrue(ibans.validate('FI1410093000123458'))
-        self.assertTrue(ibans.validate('FR7630006000011234567890189'))
-        self.assertTrue(ibans.validate('GE60NB0000000123456789'))
-        self.assertTrue(ibans.validate('DE91100000000123456789'))
-        self.assertTrue(ibans.validate('GI04BARC000001234567890'))
-        self.assertTrue(ibans.validate('GR9608100010000001234567890'))
-        self.assertTrue(ibans.validate('GL8964710123456789'))
-        self.assertTrue(ibans.validate('GT20AGRO00000000001234567890'))
-        self.assertTrue(ibans.validate('HU93116000060000000012345676'))
-        self.assertTrue(ibans.validate('IS030001121234561234567890'))
-        # self.assertTrue(ibans.validate('IQ20CBIQ861800101010500'))
-        self.assertTrue(ibans.validate('IE64IRCE92050112345678'))
-        self.assertTrue(ibans.validate('IL170108000000012612345'))
-        self.assertTrue(ibans.validate('IT60X0542811101000000123456'))
-        self.assertTrue(ibans.validate('JO71CBJO0000000000001234567890'))
-        self.assertTrue(ibans.validate('KZ563190000012344567'))
-        self.assertTrue(ibans.validate('XK051212012345678906'))
-        self.assertTrue(ibans.validate('KW81CBKU0000000000001234560101'))
-        self.assertTrue(ibans.validate('LV97HABA0012345678910'))
-        self.assertTrue(ibans.validate('LB92000700000000123123456123'))
-        self.assertTrue(ibans.validate('LI7408806123456789012'))
-        self.assertTrue(ibans.validate('LT601010012345678901'))
-        self.assertTrue(ibans.validate('LU120010001234567891'))
-        self.assertTrue(ibans.validate('MK07200002785123453'))
-        self.assertTrue(ibans.validate('MT31MALT01100000000000000000123'))
-        self.assertTrue(ibans.validate('MR1300020001010000123456753'))
-        self.assertTrue(ibans.validate('MU43BOMM0101123456789101000MUR'))
-        self.assertTrue(ibans.validate('MD21EX000000000001234567'))
-        self.assertTrue(ibans.validate('MC5810096180790123456789085'))
-        self.assertTrue(ibans.validate('ME25505000012345678951'))
-        self.assertTrue(ibans.validate('NL02ABNA0123456789'))
-        self.assertTrue(ibans.validate('NO8330001234567'))
-        self.assertTrue(ibans.validate('PK36SCBL0000001123456702'))
-        self.assertTrue(ibans.validate('PS92PALS000000000400123456702'))
-        self.assertTrue(ibans.validate('PL10105000997603123456789123'))
-        self.assertTrue(ibans.validate('PT50002700000001234567833'))
-        self.assertTrue(ibans.validate('QA54QNBA000000000000693123456'))
-        self.assertTrue(ibans.validate('RO09BCYP0000001234567890'))
-        self.assertTrue(ibans.validate('LC14BOSL123456789012345678901234'))
-        self.assertTrue(ibans.validate('SM76P0854009812123456789123'))
-        self.assertTrue(ibans.validate('ST23000200000289355710148'))
-        self.assertTrue(ibans.validate('SA4420000001234567891234'))
-        self.assertTrue(ibans.validate('RS35105008123123123173'))
-        self.assertTrue(ibans.validate('SC52BAHL01031234567890123456USD'))
-        self.assertTrue(ibans.validate('SK8975000000000012345671'))
-        self.assertTrue(ibans.validate('SI56192001234567892'))
-        self.assertTrue(ibans.validate('ES7921000813610123456789'))
-        self.assertTrue(ibans.validate('SE1412345678901234567890'))
-        self.assertTrue(ibans.validate('CH5604835012345678009'))
-        self.assertTrue(ibans.validate('TL380080012345678910157'))
-        self.assertTrue(ibans.validate('TN4401000067123456789123'))
-        self.assertTrue(ibans.validate('TR320010009999901234567890'))
-        self.assertTrue(ibans.validate('UA903052992990004149123456789'))
-        self.assertTrue(ibans.validate('AE460090000000123456789'))
-        self.assertTrue(ibans.validate('GB98MIDL07009312345678'))
-        self.assertTrue(ibans.validate('VG21PACG0000000123456789'))
-
-    def test_specificity(self):
-        self.assertEqual(ibans.specificity('VG21PACG0000000123456789'), 1)
-
-    def test_country(self):
-        iban = 'AE460090000000123456789'
-        assert 'ae' == ibans.country_hint(iban)
-        assert ibans.country_hint('') is None
-
-    def test_compare(self):
-        iban = 'AE460090000000123456789'
-        comp = ibans.compare_safe(iban, iban)
-        assert comp == 1, comp
-        comp = ibans.compare_safe(iban, iban + 'X')
-        assert comp == 0, comp
-        comp = ibans.compare_safe(iban, None)
-        assert comp == 0, comp

tests/types/test_identifiers.py

@@ -1,27 +0,0 @@
-import unittest
-
-from followthemoney.types import identifiers
-
-
-class IdentifiersTest(unittest.TestCase):
-
-    def test_parse(self):
-        self.assertEqual(identifiers.clean('88/9'), '88/9')
-
-    def test_normalize(self):
-        self.assertEqual(identifiers.normalize('FOO'), ['foo'])
-        self.assertEqual(identifiers.normalize('xx '), ['xx'])
-        self.assertEqual(identifiers.normalize(' '), [])
-
-    def test_domain_validity(self):
-        self.assertTrue(identifiers.validate('foo@pudo.org'))
-
-    def test_compare(self):
-        comp = identifiers.compare('AS98187', '98187')
-        assert comp == 0.7, comp
-        comp = identifiers.compare_safe(None, '98187')
-        assert comp == 0, comp
-        comp = identifiers.compare_sets(['AS98187'], ['98187'])
-        assert comp == 0.7, comp
-        comp = identifiers.compare_sets(['98187'], ['AS98187'])
-        assert comp == 0.7, comp

tests/types/test_ip.py

@@ -1,29 +0,0 @@
-import unittest
-
-from followthemoney.types import ips
-
-
-class IPsTest(unittest.TestCase):
-
-    def test_ip_validate(self):
-        self.assertTrue(ips.validate('172.16.254.1'))
-        self.assertFalse(ips.validate('355.16.254.1'))
-        self.assertFalse(ips.validate('16.254.1'))
-        self.assertFalse(ips.validate('172.162541'))
-        self.assertFalse(ips.validate(None))
-
-        self.assertTrue(ips.validate('2001:db8:0:1234:0:567:8:1'))
-        self.assertFalse(ips.validate('2001:zz8:0:1234:0:567:8:1'))
-        self.assertFalse(ips.validate('20001:db8:0:1234:0:567:8:1'))
-        self.assertFalse(ips.validate(None))
-
-    def test_ip_clean(self):
-        self.assertEqual(ips.clean('172.16.254.1'), '172.16.254.1')
-        self.assertEqual(ips.clean(None), None)
-        self.assertEqual(ips.clean('-1'), None)
-
-    def test_funcs(self):
-        self.assertEqual(str(ips.rdf('172.16.254.1')), 'ip:172.16.254.1')
-
-    def test_specificity(self):
-        self.assertEqual(ips.specificity('172.16.254.1'), 1)

tests/types/test_languages.py

@@ -1,23 +0,0 @@
-import unittest
-
-from followthemoney.types import languages
-
-
-class LanguagesTest(unittest.TestCase):
-
-    def test_validate(self):
-        self.assertTrue(languages.validate('de'))
-        self.assertTrue(languages.validate('en'))
-        self.assertFalse(languages.validate('us'))
-        self.assertFalse(languages.validate(None))
-
-    def test_cleam(self):
-        self.assertEquals(languages.clean('de'), 'de')
-        self.assertEquals(languages.clean('xx'), None)
-        self.assertEquals(languages.clean(None), None)
-
-    def test_funcs(self):
-        self.assertEqual(str(languages.rdf('de')), 'iso-639:de')
-
-    def test_specificity(self):
-        self.assertEqual(languages.specificity('de'), 0)

tests/types/test_names.py

@@ -1,33 +0,0 @@
-import unittest
-
-from followthemoney.types import names
-
-
-class NamesTest(unittest.TestCase):
-
-    def test_repr(self):
-        self.assertEqual(repr(names), '<NameType()>')
-
-    def test_parse(self):
-        self.assertEqual(names.clean('Hans Well'), 'Hans Well')
-        self.assertEqual(names.clean('Hans   Well '), 'Hans Well')
-        self.assertEqual(names.clean('"Hans Well"'), 'Hans Well')
-
-    def test_normalize(self):
-        self.assertEqual(names.normalize('FOO'), ['FOO'])
-        self.assertEqual(names.normalize('xx '), ['xx'])
-        self.assertEqual(names.normalize(' '), [])
-
-    def test_domain_validity(self):
-        self.assertTrue(names.validate('huhu'))
-        self.assertFalse(names.validate(''))
-
-    def test_normalize_set(self):
-        self.assertEqual(names.normalize_set('FOO'), ['FOO'])
-        self.assertEqual(names.normalize_set(['FOO', '']), ['FOO'])
-        self.assertEqual(names.normalize_set(['FOO', 'FOO']), ['FOO'])
-        self.assertEqual(len(names.normalize_set(['FOO', 'BAR'])), 2)
-
-    def test_specificity(self):
-        self.assertEqual(names.specificity('bo'), 0)
-        self.assertGreater(names.specificity('boban'), 0)

tests/types/test_phones.py

@@ -1,24 +0,0 @@
-import unittest
-
-from followthemoney.types import phones
-
-
-class PhonesTest(unittest.TestCase):
-
-    def test_us_number(self):
-        self.assertEqual(phones.clean('+1-800-784-2433'), '+18007842433')
-        self.assertEqual(phones.clean('+1 800 784 2433'), '+18007842433')
-        self.assertEqual(phones.clean('+18007842433'), '+18007842433')
-        self.assertEqual(phones.clean('+1 555 8379'), None)
-
-    def test_de_number(self):
-        self.assertEqual(phones.clean('017623423980'), None)
-        self.assertEqual(phones.clean('017623423980', countries='DE'),
-                         '+4917623423980')
-
-    def test_specificity(self):
-        self.assertEqual(phones.specificity('+4917623423980'), 1)
-
-    def test_country_hint(self):
-        self.assertEqual(phones.country_hint('+4917623423980'), 'de')
-        self.assertEqual(phones.country_hint(None), None)

tests/types/test_registry.py

@@ -1,14 +0,0 @@
-import unittest
-
-from followthemoney.types import registry
-
-
-class RegistryTest(unittest.TestCase):
-
-    def test_ref(self):
-        assert registry.entity == registry.get('entity')
-        assert registry.get('banana') is None
-        assert registry.entity.ref('banana') == 'e:banana'
-        t, v = registry.deref('e:banana')
-        assert t == registry.entity
-        assert v == 'banana'

tests/types/test_urls.py

@@ -1,23 +0,0 @@
-import unittest
-
-from followthemoney.types import urls
-
-
-class UrlsTest(unittest.TestCase):
-
-    def test_is_url(self):
-        self.assertTrue(urls.validate('http://foo.org'))
-        self.assertFalse(urls.validate(None))
-        self.assertFalse(urls.validate('hello'))
-
-    def test_parse_url(self):
-        self.assertEqual(urls.clean('http://foo.com'), 'http://foo.com/')
-        self.assertEqual(urls.clean('http://foo.com/#lala'), 'http://foo.com/')
-
-        self.assertEqual(urls.clean('http://foo.com?b=1&a=2'),
-                         'http://foo.com/?a=2&b=1')
-        self.assertEqual(urls.clean('http://FOO.com'), 'http://foo.com/')
-        self.assertEqual(urls.clean('http://FOO.com/A'), 'http://foo.com/A')
-
-    def test_specificity(self):
-        self.assertEqual(urls.specificity('http://foo.com/'), 1)