13059236656

Committed 30 Jan 2025 06:54PM UTC coverage: 95.923% (-0.01%) from 95.935%

Build # 13059236656

Build Type

push

github

Committed by

fcurella

Commit Message

Merge branch 'ChristinaRau-fix/master/new-de-providers'

Coverage Stats

193 of 197 new or added lines in 24 files covered. (97.97%)

7 existing lines in 4 files now uncovered.

10400 of 10842 relevant lines covered (95.92%)

18.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.77

/faker/providers/address/es_AR/__init__.py

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, 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

1	from collections import OrderedDict	19✔
2	from typing import List, Tuple	19✔
3
4	from ..es import Provider as AddressProvider	19✔
5
6
7	class Provider(AddressProvider):	19✔
8	provinces = {	19✔
9	"CABA": "Ciudad Autónoma de Buenos Aires",
10	"BA": "Buenos Aires",
11	"CA": "Catamarca",
12	"CH": "Chaco",
13	"CT": "Chubut",
14	"CB": "Córdoba",
15	"CR": "Corrientes",
16	"ER": "Entre Ríos",
17	"FO": "Formosa",
18	"JY": "Jujuy",
19	"LP": "La Pampa",
20	"LR": "La Rioja",
21	"MZ": "Mendoza",
22	"MI": "Misiones",
23	"NQN": "Neuquén",
24	"RN": "Río Negro",
25	"SA": "Salta",
26	"SJ": "San Juan",
27	"SL": "San Luis",
28	"SC": "Santa Cruz",
29	"SF": "Santa Fe",
30	"SE": "Santiago del Estero",
31	"TF": "Tierra del Fuego",
32	"TU": "Tucumán",
33	}
34
35	municipalities: List[Tuple[str, str, str]] = [	19✔
36	("1004", "Constitución", "CABA"),
37	("1900", "La Plata", "BA"),
38	("7600", "Mar del Plata", "BA"),
39	("8000", "Bahía Blanca", "BA"),
40	("4700", "San Ferando del Valle de Catamarca", "CA"),
41	("3500", "Resistencia", "CH"),
42	("9103", "Rawson", "CT"),
43	("9000", "Comodoro Rivadavia", "CT"),
44	("5000", "Córdoba", "CB"),
45	("3400", "Corrientes", "CR"),
46	("3100", "Paraná", "ER"),
47	("3600", "Formosa", "FO"),
48	("4600", "San Salvador de Jujuy", "JY"),
49	("6300", "Santa Rosa", "LP"),
50	("5300", "La Rioja", "LR"),
51	("5360", "Chilecito", "LR"),
52	("5500", "Mendoza", "MZ"),
53	("3300", "Posadas", "MI"),
54	("8300", "Neuquén", "NQN"),
55	("8500", "Viedma", "RN"),
56	("4400", "Salta", "SA"),
57	("5400", "San Juan", "SJ"),
58	("5700", "San Luis", "SL"),
59	("5881", "Merlo", "SL"),
60	("9400", "Río Gallegos", "SC"),
61	("3000", "Santa Fe", "SF"),
62	("2000", "Rosario", "SF"),
63	("4200", "Santiago del Estero", "SE"),
64	("9410", "Ushuaia", "TF"),
65	("4000", "San Miguel de Tucumán", "TU"),
66	]
67
68	street_prefixes = OrderedDict(	19✔
69	[
70	("Calle", 0.2),
71	("Avenida", 0.2),
72	("Av.", 0.2),
73	("Diagonal", 0.2),
74	("Diag.", 0.05),
75	("Camino", 0.05),
76	("Boulevard", 0.05),
77	("Blv.", 0.05),
78	]
79	)
80	street_suffixes = ["A", "B", "Bis"]	19✔
81
82	street_proceres = (	19✔
83	"San Martin",
84	"Belgrano",
85	"Saavedra",
86	"Rivadavia",
87	"Güemes",
88	"G. Brown",
89	"J.B. Alberdi",
90	"J.M. de Rosas",
91	"J.J. Castelli",
92	"Mitre",
93	"Alem",
94	"Alvear",
95	"Malvinas Argentinas",
96	"Pte. Perón",
97	"Omar Nuñez",
98	)
99	street_name_formats = OrderedDict(	19✔
100	[
101	("{{street_prefix}} %", 0.2),
102	("{{street_prefix}} {{street_municipality}}", 0.2),
103	("{{street_prefix}} {{street_province}}", 0.2),
104	("{{street_prefix}} {{street_procer}}", 0.2),
105	("{{street_prefix}} 1## {{street_suffix}}", 0.02),
106	]
107	)
108	building_number_formats = OrderedDict(	19✔
109	[
110	("%%", 0.2),
111	("%%#", 0.2),
112	("%#%", 0.2),
113	("%#%#", 0.2),
114	]
115	)
116	secondary_address_formats = [	19✔
117	"Piso % Dto. %",
118	"Dto. %",
119	"Torre % Dto. %",
120	"Local %!",
121	"Oficina %!",
122	]
123	postcode_formats = ["{{municipality_code}}####"]	19✔
124
125	def provinces_code(self) -> str:	19✔
126	"""
127	:example: "BA"
128	"""
129	return self.random_element(self.provinces.keys())	×
130
131	def province(self) -> str:	19✔
132	"""
133	:example: "Buenos Aires"
134	"""
135	return self.random_element(list(self.provinces.values()))	19✔
136
137	administrative_unit = province	19✔
138
139	def municipality_code(self) -> str:	19✔
140	"""
141	:example: "1900"
142	"""
143	return self.random_element(self.municipalities)[0] # type: ignore	19✔
144
145	def municipality(self) -> str:	19✔
146	"""
147	:example: "La Plata"
148	"""
149	return self.random_element(self.municipalities)[1] # type: ignore	19✔
150
151	city = municipality	19✔
152
153	def street_prefix(self) -> str:	19✔
154	"""
155	:example: "Calle"
156	"""
157	return self.random_element(self.street_prefixes)	19✔
158
159	def street_procer(self) -> str:	19✔
160	"""
161	:example: "Belgrano"
162	"""
163	return self.random_element(self.street_proceres)	8✔
164
165	def street_municipality(self) -> str:	19✔
166	"""
167	:example: "La Plata"
168	"""
169	return self.random_element(self.municipalities)[1]	12✔
170
171	def street_province(self) -> str:	19✔
172	"""
173	:example: "San Juan"
174	"""
175	return self.random_element(list(self.provinces.values()))	7✔
176
177	def street_suffix(self) -> str:	19✔
178	"""
179	:example: "Sur"
180	"""
UNCOV 181	return self.generator.parse(self.random_element(self.street_suffixes))	×
182
183	def street_name(self) -> str:	19✔
184	"""
185	:example: "Calle 1"
186	"""
187	pattern: str = self.random_element(self.street_name_formats)	19✔
188	return self.numerify(self.generator.parse(pattern))	19✔
189
190	def building_number(self) -> str:	19✔
191	"""
192	:example: "23"
193	"""
194	return self.numerify(self.generator.parse(self.random_element(self.building_number_formats)))	19✔
195
196	def secondary_address(self) -> str:	19✔
197	"""
198	:example: "Departamento 123"
199	"""
200	return self.numerify(self.random_element(self.secondary_address_formats))	×
201
202	def street_address(self) -> str:	19✔
203	"""
204	:example: "Calle 1 N° 23"
205	"""
206	return self.street_name() + " N° " + self.building_number()	19✔
207
208	def postcode(self) -> str:	19✔
209	"""
210	:example: "1900"
211	"""
212	return self.numerify(self.generator.parse(self.random_element(self.postcode_formats)))	19✔
213
214	def address(self) -> str:	19✔
215	"""
216	:example: "Calle 1 N° 23, La Plata 1900, Buenos Aires"
217	"""
218	municipality: Tuple[str, str, str] = self.random_element(self.municipalities)	×
219	municipality_code = municipality[0]	×
220	municipality_prov = municipality[2]	×
221
222	secondary_address: str = self.random_element(	×
223	[
224	" " + self.secondary_address(),
225	"",
226	]
227	)
228	postcode = "\n" + municipality[1] + " " + municipality_code	×
229	province_name = ", " + self.provinces[municipality_prov]	×
230
231	return self.street_address() + secondary_address + postcode + province_name	×

joke2k / faker / 13059236656

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous