Add es_AR Argentina providers

faker/providers/address/es_AR/__init__.py

@@ -0,0 +1,234 @@
+from collections import OrderedDict
+from typing import List, Tuple
+
+from ..es import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+
+    provinces = {
+        "CABA": "Ciudad Autónoma de Buenos Aires",
+        "BA": "Buenos Aires",
+        "CA": "Catamarca",
+        "CH": "Chaco",
+        "CT": "Chubut",
+        "CB": "Córdoba",
+        "CR": "Corrientes",
+        "ER": "Entre Ríos",
+        "FO": "Formosa",
+        "JY": "Jujuy",
+        "LP": "La Pampa",
+        "LR": "La Rioja",
+        "MZ": "Mendoza",
+        "MI": "Misiones",
+        "NQN": "Neuquén",
+        "RN": "Río Negro",
+        "SA": "Salta",
+        "SJ": "San Juan",
+        "SL": "San Luis",
+        "SC": "Santa Cruz",
+        "SF": "Santa Fe",
+        "SE": "Santiago del Estero",
+        "TF": "Tierra del Fuego",
+        "TU": "Tucumán",
+    }
+
+    municipalities: List[Tuple[str, str, str]] = [
+        ("1004", "Constitución", "CABA"),
+        ("1900", "La Plata", "BA"),
+        ("7600", "Mar del Plata", "BA"),
+        ("8000", "Bahía Blanca", "BA"),
+        ("4700", "San Ferando del Valle de Catamarca", "CA"),
+        ("3500", "Resistencia", "CH"),
+        ("9103", "Rawson", "CT"),
+        ("9000", "Comodoro Rivadavia", "CT"),
+        ("5000", "Córdoba", "CB"),
+        ("3400", "Corrientes", "CR"),
+        ("3100", "Paraná", "ER"),
+        ("3600", "Formosa", "FO"),
+        ("4600", "San Salvador de Jujuy", "JY"),
+        ("6300", "Santa Rosa", "LP"),
+        ("5300", "La Rioja", "LR"),
+        ("5360", "Chilecito", "LR"),
+        ("5500", "Mendoza", "MZ"),
+        ("3300", "Posadas", "MI"),
+        ("8300", "Neuquén", "NQN"),
+        ("8500", "Viedma", "RN"),
+        ("4400", "Salta", "SA"),
+        ("5400", "San Juan", "SJ"),
+        ("5700", "San Luis", "SL"),
+        ("5881", "Merlo", "SL"),
+        ("9400", "Río Gallegos", "SC"),
+        ("3000", "Santa Fe", "SF"),
+        ("2000", "Rosario", "SF"),
+        ("4200", "Santiago del Estero", "SE"),
+        ("9410", "Ushuaia", "TF"),
+        ("4000", "San Miguel de Tucumán", "TU"),
+
+    ]
+
+    street_prefixes = OrderedDict(
+        [
+            ("Calle", 0.2),
+            ("Avenida", 0.2),
+            ("Av.", 0.2),
+            ("Diagonal", 0.2),
+            ("Diag.", 0.05),
+            ("Camino", 0.05),
+            ("Boulevard", 0.05),
+            ("Blv.", 0.05),
+        ]
+    )
+    street_suffixes = ["A", "B", "Bis"]
+
+    street_proceres = ("San Martin",
+            "Belgrano",
+            "Saavedra",
+            "Rivadavia",
+            "Güemes",
+            "G. Brown",
+            "J.B. Alberdi",
+            "J.M. de Rosas",
+            "J.J. Castelli",
+            "Mitre",
+            "Alem",
+            "Alvear",
+            "Malvinas Argentinas",
+            "Pte. Perón",
+            "Omar Nuñez",
+    )
+    street_name_formats = OrderedDict(
+        [
+            ("{{street_prefix}} %", 0.2),
+            ("{{street_prefix}} {{street_municipality}}", 0.2),
+            ("{{street_prefix}} {{street_province}}", 0.2),
+            ("{{street_prefix}} {{street_procer}}", 0.2),
+            ("{{street_prefix}} 1## {{street_suffix}}", 0.02),
+        ]
+    )
+    building_number_formats = OrderedDict(
+        [
+            ("%%", 0.2),
+            ("%%#", 0.2),
+            ("%#%", 0.2),
+            ("%#%#", 0.2),
+        ]
+    )
+    secondary_address_formats = [
+        "Piso % Dto. %",
+        "Dto. %",
+        "Torre % Dto. %",
+        "Local %!",
+        "Oficina %!",
+    ]
+    postcode_formats = ["{{municipality_code}}####"]
+
+    def provinces_code(self) -> str:
+        """
+        :example: "BA"
+        """
+        return self.random_element(self.provinces.keys())
+
+    def province(self) -> str:
+        """
+        :example: "Buenos Aires"
+        """
+        return self.random_element(list(self.provinces.values()))
+
+    administrative_unit = province
+
+    def municipality_code(self) -> str:
+        """
+        :example: "1900"
+        """
+        return self.random_element(self.municipalities)[0]  # type: ignore
+
+    def municipality(self) -> str:
+        """
+        :example: "La Plata"
+        """
+        return self.random_element(self.municipalities)[1]  # type: ignore
+
+    city = municipality
+
+    def street_prefix(self) -> str:
+        """
+        :example: "Calle"
+        """
+        return self.random_element(self.street_prefixes)
+
+    def street_procer(self) -> str:
+        """
+        :example: "Belgrano"
+        """
+        return self.random_element(self.street_proceres)
+
+    def street_municipality(self) -> str:
+        """
+        :example: "La Plata"
+        """
+        return self.random_element(self.municipalities)[1]
+
+    def street_province(self) -> str:
+        """
+        :example: "San Juan"
+        """
+        return self.random_element(list(self.provinces.values()))
+
+    def street_suffix(self) -> str:
+        """
+        :example: "Sur"
+        """
+        return self.generator.parse(self.random_element(self.street_suffixes))
+
+    def street_name(self) -> str:
+        """
+        :example: "Calle 1"
+        """
+        pattern: str = self.random_element(self.street_name_formats)
+        return self.numerify(self.generator.parse(pattern))
+
+    def building_number(self) -> str:
+        """
+        :example: "23"
+        """
+        return self.numerify(self.generator.parse(self.random_element(self.building_number_formats)))
+
+
+    def secondary_address(self) -> str:
+        """
+        :example: "Departamento 123"
+        """
+        return self.numerify(self.random_element(self.secondary_address_formats))
+
+    def street_address(self) -> str:
+        """
+        :example: "Calle 1 N° 23"
+        """
+        return self.street_name() + " N° " + self.building_number()
+
+    def postcode(self) -> str:
+        """
+        :example: "1900"
+        """
+        return self.numerify(self.generator.parse(self.random_element(self.postcode_formats)))
+
+    def address(self) -> str:
+        """
+        :example: "Calle 1 N° 23, La Plata 1900, Buenos Aires"
+        """
+        municipality: Tuple[str, str] = self.random_element(self.municipalities)
+        municipality_code = municipality[0]
+        municipality_prov = municipality[2]
+
+
+        secondary_address: str = self.random_element(
+            [
+                " " + self.secondary_address(),
+                "",
+            ]
+        )
+        postcode = "\n"+ municipality[1] +" "+ municipality_code
+        province_name = ", "+self.provinces[municipality_prov]
+
+        return self.street_address() + secondary_address + postcode + province_name

faker/providers/automotive/es_AR/__init__.py

@@ -0,0 +1,87 @@
+from collections import OrderedDict
+from string import ascii_uppercase
+
+from .. import Provider as AutomotiveProvider
+
+
+class Provider(AutomotiveProvider):
+    """Implement automotive provider for ``es_AR`` locale.
+
+    Sources:
+
+    - https://en.wikipedia.org/wiki/Vehicle_registration_plates_of_Argentina
+
+    """
+
+    license_plate_old_format_first_letter = ascii_uppercase.replace('YZ','')
+
+    license_plate_new_first_letter = OrderedDict(
+        [
+            ("A",0.99),
+            ("B",0.001),
+            ("C",0.0001),
+            ("D",0.00001),
+            ("E",0.0000000001),
+        ]
+    )
+
+    license_plate_new_second_letter = OrderedDict(
+        [
+            ("A",0.1),
+            ("B",0.1),
+            ("C",0.1),
+            ("D",0.1),
+            ("E",0.1),
+            ("F",0.1),
+            ("G",0.09),
+            ("H",0.08),
+            ("I",0.07),
+            ("J",0.06),
+            ("K",0.04),
+            ("L",0.03),
+            ("M",0.009),
+            ("N",0.007),
+            ("O",0.005),
+            ("P",0.004),
+            ("Q",0.001),
+            ("R",0.0009),
+            ("S",0.0008),
+            ("T",0.0007),
+            ("U",0.0006),
+            ("V",0.0005),
+            ("W",0.0003),
+            ("X",0.0002),
+            ("Y",0.0001),
+            ("Z",0.00005),
+        ]
+    )
+
+    license_formats = OrderedDict(
+        [
+            ("{{license_plate_old}}", 0.6),
+            ("{{license_plate_mercosur}}", 0.4),
+        ]
+    )
+
+    def license_plate_old(self) -> str:
+        """Generate an old format license plate. Since 1995 to 2016"""
+        format = "??###"
+
+        first_letter = self.random_element(self.license_plate_old_format_first_letter)
+
+        return self.bothify(first_letter + format).upper()
+
+    def license_plate_mercosur(self) -> str:
+        """Generate an new plate with Mercosur format. Since 2016"""
+
+        first_letter= self.random_element(self.license_plate_new_first_letter)
+        second_letter= self.random_element(self.license_plate_new_second_letter)
+
+        format = "###??"
+        plate = first_letter + second_letter
+
+        return self.bothify(plate + format).upper()
+
+    def license_plate(self) -> str:
+        """Generate a license plate."""
+        return self.numerify(self.generator.parse(self.random_element(self.license_formats)))

faker/providers/bank/es_AR/__init__.py

@@ -0,0 +1,36 @@
+from .. import Provider as BankProvider
+
+
+class Provider(BankProvider):
+    """Implement bank provider for ``es_AR`` locale.
+    source: https://www.bcra.gob.ar/SistemasFinancierosYdePagos/Activos.asp"""
+
+    bban_format = "????####################"
+    country_code = "AR"
+
+    banks = (
+        "Banco de la Nación Argentina",
+        "Banco Santander",
+        "Banco de Galicia y Buenos Aires",
+        "Banco de la Provincia de Buenos Aires",
+        "BBVA Argentina",
+        "Banco Macro",
+        "HSBC Bank Argentina",
+        "Banco Ciudad de Buenos Aires",
+        "Banco Credicoop",
+        "Industrial And Commercial Bank Of China",
+        "Citibank",
+        "Banco Patagonia",
+        "Banco de la Provincia de Córdoba",
+        "Banco Supervielle",
+        "Nuevo Banco de Santa Fe",
+        "Banco Hipotecario S. A.",
+        "Banco Itaú Argentina",
+        "Banco de Inversión y Comercio Exterior (BICE)",
+        "Banco Comafi",
+        "BSE - Banco Santiago del Estero"
+        )
+
+    def bank(self):
+        """Generate a bank name."""
+        return self.random_element(self.banks)

faker/providers/currency/es_AR/__init__.py

@@ -0,0 +1,8 @@
+from ..es import Provider as CurrencyProvider
+
+
+class Provider(CurrencyProvider):
+    price_formats = ["%##", "%.###", "%#.##0", "%##.##0", "%##.##0", "%.###.##0", "%#,##"]
+
+    def pricetag(self) -> str:
+        return "$"+ self.numerify(self.random_element(self.price_formats))

faker/providers/date_time/es_AR/__init__.py

@@ -0,0 +1,5 @@
+from ..es import Provider as DateTimeProvider
+
+
+class Provider(DateTimeProvider):
+    pass

faker/providers/internet/es_AR/__init__.py

@@ -0,0 +1,21 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    safe_email_tlds = ("com", "net", "ar")
+    tlds = ("com", "com.ar", "com.ar", "net", "org", "net.ar", "ar", "ar")
+    replacements = (
+        ("à", "a"),
+        ("â", "a"),
+        ("ã", "a"),
+        ("á", "a"),
+        ("ç", "c"),
+        ("é", "e"),
+        ("ê", "e"),
+        ("í", "i"),
+        ("ô", "o"),
+        ("ö", "o"),
+        ("õ", "o"),
+        ("ó", "o"),
+        ("ú", "u"),
+    )