def test_search_error():
with pytest.raises(KeyError):
get_address_from_cep('37.503-130', webservice=5)
with pytest.raises(KeyError):
get_address_from_cep('37.503-130', webservice='VIACEP')
def test_fetch_address_connection_error(requests_mock):
requests_mock.get('http://www.viacep.com.br/ws/37503130/json',
exc=requests.exceptions.ConnectTimeout) # noqa
with pytest.raises(exceptions.ConnectionError):
get_address_from_cep('37503-130', webservice=WebService.VIACEP)
def test_fetch_address_request_exception(requests_mock):
requests_mock.get('http://www.viacep.com.br/ws/37503130/json',
exc=requests.exceptions.RequestException) # noqa
with pytest.raises(exceptions.BaseException):
get_address_from_cep('37503-130', webservice=WebService.VIACEP)
def test_fetch_address_fail():
# Realizamos a consulta de CEP
with pytest.raises(exceptions.CEPNotFound):
get_address_from_cep('00000-000', webservice=WebService.APICEP)
with pytest.raises(exceptions.InvalidCEP):
get_address_from_cep('37503-13', webservice=WebService.APICEP)
def test_fetch_address_fail(mk):
class MockClass:
def __init__(self, dictionary):
for k, v in dictionary.items():
setattr(self, k, v)
service_mk = mk.return_value.service
# Criamos o mock para o valor de retorno
service_mk.consultaCEP.side_effect = zeep.exceptions.Fault('error', 500)
with pytest.raises(exceptions.BaseException):
get_address_from_cep('37503130', webservice=WebService.CORREIOS)
def _consultar_cep(self, zip_code):
zip_str = misc.punctuation_rm(zip_code)
try:
cep = pycep_correios.get_address_from_cep(zip_str)
except Exception as e:
raise UserError(_("Erro no PyCEP-Correios : ") + str(e))
values = {}
if cep:
# Search Brazil id
country = self.env["res.country"].search([("code", "=", "BR")],
limit=1)
# Search state with state_code and country id
state = self.env["res.country.state"].search(
[("code", "=", cep.get("uf")),
("country_id", "=", country.id)],
limit=1)
# search city with name and state
city = self.env["res.city"].search(
[("name", "=", cep.get("cidade")),
("state_id.id", "=", state.id)],
limit=1)
values = {
"zip_code": zip_str,
"street": cep.get("logradouro"),
"zip_complement": cep.get("complemento"),
"district": cep.get("bairro"),
"city_id": city.id or False,
"state_id": state.id or False,
"country_id": country.id or False,
}
return values
def test_fetch_address_success(mk):
class MockClass:
def __init__(self, dictionary):
for k, v in dictionary.items():
setattr(self, k, v)
expected_address = {
'bairro': 'Santo Antônio',
'cep': '37503130',
'cidade': 'Itajubá',
'complemento2': '- até 214/215',
'end': 'Rua Geraldino Campista',
'uf': 'MG',
'unidadesPostagem': [],
}
service_mk = mk.return_value.service
# Criamos o mock para o valor de retorno
service_mk.consultaCEP.return_value = MockClass(expected_address)
# Realizamos a consulta de CEP
endereco = get_address_from_cep('37503130', webservice=WebService.CORREIOS)
assert endereco['bairro'] == 'Santo Antônio'
assert endereco['cep'] == '37503130'
assert endereco['cidade'] == 'Itajubá'
assert endereco['complemento'] == '- até 214/215'
assert endereco['logradouro'] == 'Rua Geraldino Campista'
assert endereco['uf'] == 'MG'
# Verifica se o metodo consultaCEP foi chamado
# com os parametros corretos
service_mk.consultaCEP.assert_called_with('37503130')
def printar():
cep1 = cep.get()
endereco = pycep_correios.get_address_from_cep(cep1)
resultado1 = Label(window, text='Logradouro: ' +
endereco['logradouro']).grid(row=5,
column=0,
columnspan=3)
resultado2 = Label(window,
text='Bairro: ' + endereco['bairro']).grid(row=6,
column=0,
columnspan=3)
resultado3 = Label(window,
text='Cidade: ' + endereco['cidade']).grid(row=7,
column=0,
columnspan=3)
resultado4 = Label(window, text='Complemento: ' +
endereco['complemento']).grid(row=8,
column=0,
columnspan=3)
resultado5 = Label(window, text='UF: ' + endereco['uf']).grid(row=9,
column=0,
columnspan=3)
resultado6 = Label(window,
text='CEP: ' + endereco['cep']).grid(row=10,
column=0,
columnspan=3)
def get_name(cep):
"""Get the street name from postal office website."""
try:
address = pycep_correios.get_address_from_cep(cep)
except (ValueError, KeyError, pycep_correios.exceptions.BaseException):
return False
return address
def verifica_cep_correios(cep):
cep_inicial = cep
k = len(cep) - 1
while cep != '00000000':
try:
endereco = pycep_correios.get_address_from_cep(cep)
salva_log('Correios' + ';' + 'CEP encontrado' + ';' + cep_inicial +
';' + endereco['cep'] + ';' + endereco['cidade'] + ';' +
endereco['uf'] + ';' + endereco['logradouro'] + ';' +
endereco['bairro'])
return (endereco)
except Exception as err:
endereco = ("CEP inválido: " + cep + str(err))
pass
cep = cep[:k]
cep = cep + '0' * (8 - k)
k = k - 1
#return endereco
salva_log('Correios' + ';' + "Cep não encontrado")
return ("Cep não encontrado")
def main(**kwargs):
address = ''
zip_code = ''
for item in kwargs:
if item == 'zip_code':
zip_code = kwargs[item]
get_address = pycep_correios.get_address_from_cep(zip_code)
address = f"{get_address['logradouro']},{get_address['cidade']}-{get_address['bairro']}"
elif item == 'formatted_address':
address = kwargs[item]
geolocator = Nominatim(
user_agent=
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"
)
location = geolocator.geocode(address)
data = {
'latitude': location.latitude,
'longitude': location.longitude,
'zip_code': zip_code,
'delivery_fee_max': '9',
'min_price': '1.0',
'max_price': '20.0'
}
i_food = IfoodAPI()
restaurants = i_food.tracker(data['latitude'],
data['longitude'], data['zip_code'],
num(data['delivery_fee_max']),
num(data['min_price']),
num(data['max_price']))
print(restaurants)
def get_address_from_cep(cep):
mapping = {
'bairro': 'neighborhood',
'cep': 'cep',
'cidade': 'city',
'logradouro': 'street',
'uf': 'state',
'complemento': 'complement'
}
return {mapping.get(k, k):v for k,v in pycep_correios.get_address_from_cep(cep).items()}
def cep(x):
print("========== CEP=============")
# O CEP é armazenado como um dicionário e utilizando o módulo get_address_from_cep()
inf_cep = pycep_correios.get_address_from_cep(x) #sys.argv[1] irá pegar o input do usuário
print("CEP => {}".format(inf_cep["cep"]))
print("Cidade => {}".format(inf_cep["cidade"]))
print("Estado => {}".format(inf_cep["uf"]))
print("Bairro => {}".format(inf_cep["bairro"]))
print("Endereço => {}".format(inf_cep["logradouro"]))
print("Complemento => {}".format(inf_cep["complemento"]))
def ConsultarCep(event=None):
try:
resultado = dict()
resultado = get_address_from_cep(ECep.get() + ECep2.get())
try:
# Carregar Campos retornados na Tela
MudarStatus(True)
if resultado['cidade'] == '' and resultado['uf'] == '':
EntRua.config(state=NORMAL)
EntBairro.config(state=NORMAL)
EntCidade.config(state=NORMAL)
EntCidade.bind("<KeyRelease>", Upper_City)
EntUf.bind("<KeyRelease>", Upper_Uf)
EntUf.config(state=NORMAL)
EntRua.focus()
elif resultado['logradouro'] == '' and resultado['bairro'] == '':
EntRua.config(state=NORMAL)
EntBairro.config(state=NORMAL)
EntRua.focus()
EntCidade.delete(0, END)
EntCidade.insert(0, resultado['cidade'].upper())
EntUf.delete(0, END)
EntUf.insert(0, resultado['uf'])
EntCidade.config(state=DISABLED)
EntUf.config(state=DISABLED)
else:
EntRua.delete(0, END)
EntRua.insert(0, resultado['logradouro'])
EntBairro.delete(0, END)
EntBairro.insert(0, resultado['bairro'])
EntCidade.delete(0, END)
EntCidade.insert(0, resultado['cidade'].upper())
EntUf.delete(0, END)
EntUf.insert(0, resultado['uf'])
MudarStatus(False)
EntNum.focus()
except:
messagebox.showerror("Erro Consulta CEP", "O CEP informado não é válido")
ECep.focus()
return resultado
except:
Cep_Consulta = messagebox.askyesno("SEM CONEXÃO", "SEM CONEXÃO COM INTERNET! DESEJA CONTINUAR")
if Cep_Consulta == True:
EntRua.config(state=NORMAL)
EntBairro.config(state=NORMAL)
EntCidade.config(state=NORMAL)
EntUf.config(state=NORMAL)
EntRua.focus()
EntCidade.bind("<KeyRelease>", Upper_City)
EntUf.bind("<KeyRelease>", Upper_Uf)
else:
Sair_Clientes()
def cep_loader(csv_file='../data/ceps_sem_localidades.csv', db_path='../data/cepsdb.db'):
'''
function that verifies if a database already exists,
if a table already exists on this db and, finally,
populate the database with ceps and localities.
csv_file: path to a csv file with index and cep columns
db_file: path to a database file. If not exists, will be created
'''
# if error, rollback automatically, else commit!
sqlite3.register_adapter(np.int64, lambda val: int(val))
with sqlite3.connect(db_path) as conn:
cursor = conn.cursor()
cursor.execute('SELECT SQLITE_VERSION()')
data = cursor.fetchone()
print('SQLite version:', data)
conn = sqlite3.connect(db_path)
cur = conn.cursor()
cur.execute('''CREATE TABLE IF NOT EXISTS Pareamento(cep INTEGER, localidade TEXT)''')
df = pd.read_csv(csv_file, sep=',')
count_news = 0
count_exists = 0
for index, row in df.iterrows():
cep = row['CEP']
cur.execute("SELECT cep FROM Pareamento WHERE cep= ?", (cep,))
try:
data = cur.fetchone()[0]
print("Found in database ", data)
count_exists += 1
# continue jumps to next iteration if cep is found in db
continue
except:
pass
# if len(cep) != 8, its not a valid cep
if not len(str(cep)) == 8:
continue
try:
address = get_address_from_cep(str(cep), webservice=WebService.CORREIOS)
localidade = address['bairro']
count_news += 1
except:
localidade = 'Cep nao encontrado'
print(f'Inserindo registro, CEP: {cep}, Localidade: {localidade}')
sql = '''INSERT INTO Pareamento(cep, localidade)
VALUES(?,?)'''
cur.execute(sql, (np.int64(cep), localidade))
conn.commit()
# Consulta para saber se os dados estão sendo salvos corretamente
# cur.execute("SELECT * FROM Pareamento WHERE cep= ?", (cep,))
# data = cur.fetchone()
# print(data)
print(f'CEPs existentes no banco: {count_exists}\nCEPs adicionados: {count_news}')
def test_fetch_address_success():
# Realizamos a consulta de CEP
address = get_address_from_cep('37.503-130', webservice=WebService.APICEP)
assert address['bairro'] == 'Santo Antônio'
assert address['cep'] == '37503-130'
assert address['cidade'] == 'Itajubá'
assert address['complemento'] == ''
assert address['logradouro'] == 'Rua Geraldino Campista'
assert address['uf'] == 'MG'
def test_success():
# Realizamos a consulta de CEP
endereco = get_address_from_cep('37.503-130')
assert endereco['bairro'] == 'Santo Antônio'
assert endereco['cep'] == '37503-130'
assert endereco['cidade'] == 'Itajubá'
assert endereco['complemento'] == 'até 214/215'
assert endereco['logradouro'] == 'Rua Geraldino Campista'
assert endereco['uf'] == 'MG'
def find(cepcodevalue):
# explica aqui o que È os correios e que essa api È fornceida por eles de graÁa
completeaddress = pycep_correios.get_address_from_cep(cepcodevalue)
# os cÛdigos abaixo mostra no console o resultado como funcionalidade de log
print(completeaddress['logradouro'])
print(completeaddress['bairro'])
print(completeaddress['cidade'])
print(completeaddress['uf'])
print(completeaddress['cep'])
return completeaddress
def get(self, cep):
endereco = pycep_correios.get_address_from_cep(cep)
geolocator = Nominatim(user_agent="api_teste")
location = geolocator.geocode('{cidade} - {bairro},'.format(
cidade=endereco['cidade'], bairro=endereco['bairro']))
if (location != None):
return {
'latitude': location.latitude,
'longitude': location.longitude
}
else:
return {'error': True}
def cepCorreios(self):
try:
self.cidade_entry.delete(0, END)
self.lograd_entry.delete(0, END)
self.bairro_entry.delete(0, END)
zipcode = self.cep_entry.get()
dadosCep = pycep_correios.get_address_from_cep(zipcode)
print(dadosCep)
self.cidade_entry.insert(END, dadosCep['cidade'])
self.lograd_entry.insert(END, dadosCep['logradouro'])
self.bairro_entry.insert(END, dadosCep['bairro'])
except:
messagebox.showerror("Erro CEP", "CEP não encontrado")
def validate_zipcode(self, zipcode):
"""Validate zipcode and get address by zipcode."""
if not zipcode:
raise InvalidZipCodeError()
try:
address = pycep_correios.get_address_from_cep(zipcode)
if address.get('bairro') not in AVAILABLE_ZONE:
raise ZipCodeOutOfAvailableZone()
return address
except Exception as e:
if type(e) == ZipCodeOutOfAvailableZone:
raise ZipCodeOutOfAvailableZone()
raise InvalidZipCodeError()
def index():
form = CEPForm()
if form.validate_on_submit():
cep = form.cep.data
endereco = pycep_correios.get_address_from_cep(cep)
geolocator = Nominatim(user_agent="test_app")
location = geolocator.geocode(endereco['logradouro'] + ", " +
endereco['cidade'] + " - " +
endereco['bairro'])
return render_template('map.html', location=location)
else:
print('não validou')
print(form.cep)
return render_template('index.html', form=form)
def cep(self):
self.logradPeEntry.delete(0, END)
self.bairroPeEntry.delete(0, END)
self.cidadePeEntry.delete(0, END)
self.ufPeEntry.delete(0, END)
try:
self.cep = self.cepPeEntry.get()
endcep = pycep_correios.get_address_from_cep(self.cep)
self.logradPeEntry.insert(END, endcep['logradouro'])
self.bairroPeEntry.insert(END, endcep['bairro'])
self.cidadePeEntry.insert(END, endcep['cidade'])
self.ufPeEntry.insert(END, endcep['uf'])
except:
messagebox.showinfo("GLAC", 'Zip no encontrado')
def handle(self, handler_input):
device_id = handler_input.request_envelope.context.system.device.device_id
access_token = handler_input.request_envelope.context.system.api_access_token
slots = handler_input.request_envelope.request.intent.slots
diaSlot = slots['Days'].value
proximoDiaAltura = []
proximoDiaHora = []
dadosAlturaHora = []
altura = []
headers = {"Authorization": f"Bearer {access_token}"}
cep = requests.get(
f"https://api.amazonalexa.com/v1/devices/{device_id}/settings/address/countryAndPostalCode",
headers=headers)
permissao = ['read::alexa:device:all:address:country_and_postal_code']
cep_dict = cep.json()
codigoPostal = cep_dict['postalCode']
address = get_address_from_cep(f'{codigoPostal}',
webservice=WebService.VIACEP)
cidade = address['cidade']
cidade = cidade.lower()
filtro = airtable.search('Data', str(data_atual))
for n, c in enumerate(filtro):
dadosAlturaHora.append(filtro[n]['fields'])
for v, c in enumerate(dadosAlturaHora):
if dadosAlturaHora[v]['Lugar'] == cidade:
proximoDiaAltura.append(dadosAlturaHora[v]['Altura'])
proximoDiaHora.append(dadosAlturaHora[v]['Hora'])
print(dadosAlturaHora[v])
for c in proximoDiaAltura:
if float(c) < 1.0:
altura.append('baixa')
elif float(c) >= 1.0:
altura.append('alta')
diaUsado = diaSlot[8:10]
respostaFinal = f'Amanhã, Às {proximoDiaHora[1]} a maré estará {altura[1]} com {proximoDiaAltura[1]}m de altura e às {proximoDiaHora[2]} a maré estará {altura[2]} com {proximoDiaAltura[2]}m de altura.'
handler_input.response_builder.speak(respostaFinal).set_card(
AskForPermissionsConsentCard(
permissions=permissao)).set_should_end_session(True)
return handler_input.response_builder.response
def validar_cep(zipcode):
'''Função valida de número de cep junto ao site dos Correios.
- Parâmetro: cep.
- Retorna: json com as infomações:
- Cep válidos: Logradouro/Nome; Bairro/Distrito; Localidade/UF; CEP.
- Inválidos: msn: "Cep inválido"
'''
try:
endereco = pycep_correios.get_address_from_cep(zipcode)
#exemplo: http://localhost:5000/Cep/60050220
res = endereco
return json.dumps(res, ensure_ascii=False).encode('utf8')
#return jsonify(endereco)#f'<h1>Cep {endereco}</h1>'
except:
res = f'zip code invalid.:{zipcode}.'
return json.dumps(res, ensure_ascii=False).encode('utf8')
def buscaCep(self):
ceps = []
cep = pycep_correios.get_address_from_cep(self.txtcep.get())
ceps.append(cep)
self.txtendereco.delete(0, END)
self.txtendereco.insert(0, ceps[0]['logradouro'])
self.txtnumero.delete(0, END)
self.txtbairro.delete(0, END)
self.txtbairro.insert(0, ceps[0]['bairro'])
self.txtcidade.delete(0, END)
self.txtcidade.insert(0, ceps[0]['cidade'])
self.txtestado.delete(0, END)
self.txtestado.insert(0, ceps[0]['uf'])
self.txtcep.delete(0, END)
self.txtcep.insert(0, ceps[0]['cep'])
def _consultar_cep(self, zip_code):
zip_str = misc.punctuation_rm(zip_code)
try:
cep_ws_providers = {
"apicep": WebService.APICEP,
"viacep": WebService.VIACEP,
"correios": WebService.CORREIOS,
}
cep_ws_provide = str(
self.env["ir.config_parameter"].sudo().get_param(
"l10n_zip.cep_ws_provider", default="correios"))
cep = get_address_from_cep(
zip_str, webservice=cep_ws_providers.get(cep_ws_provide))
except Exception as e:
raise UserError(_("Erro no PyCEP-Correios : ") + str(e))
values = {}
if cep and any(cep.values()):
# Search Brazil id
country = self.env["res.country"].search([("code", "=", "BR")],
limit=1)
# Search state with state_code and country id
state = self.env["res.country.state"].search(
[("code", "=", cep.get("uf")),
("country_id", "=", country.id)],
limit=1)
# search city with name and state
city = self.env["res.city"].search(
[("name", "=", cep.get("cidade")),
("state_id.id", "=", state.id)],
limit=1,
)
values = {
"zip_code": zip_str,
"street": cep.get("logradouro"),
"zip_complement": cep.get("complemento"),
"district": cep.get("bairro"),
"city_id": city.id or False,
"state_id": state.id or False,
"country_id": country.id or False,
}
return values
def ConsultarCep(event=None):
try:
resultado = dict()
resultado = get_address_from_cep(Var_Cep1_Ind.get() + Var_Cep2_Ind.get())
try:
# Carregar Campos retornados na Tela
MudarStatus(True)
if resultado['cidade'] == '' and resultado['uf'] == '':
EntStreet_Ind.config(state=NORMAL)
EntBairro_Ind.config(state=NORMAL)
Ent_City_Ind.config(state=NORMAL)
Ent_City_Ind.bind("<KeyRelease>", Upper_City)
EntUf_Ind.bind("<KeyRelease>", Upper_Uf)
EntUf_Ind.config(state=NORMAL)
EntStreet_Ind.focus()
elif resultado['logradouro'] == '' and resultado['bairro'] == '':
EntStreet_Ind.config(state=NORMAL)
EntBairro_Ind.config(state=NORMAL)
EntStreet_Ind.focus()
Ent_City_Ind.delete(0, END)
Ent_City_Ind.insert(0, resultado['cidade'].upper())
EntUf_Ind.delete(0, END)
EntUf_Ind.insert(0, resultado['uf'])
Ent_City_Ind.config(state=DISABLED)
EntUf_Ind.config(state=DISABLED)
else:
EntStreet_Ind.delete(0, END)
EntStreet_Ind.insert(0, resultado['logradouro'])
EntBairro_Ind.delete(0, END)
EntBairro_Ind.insert(0, resultado['bairro'])
Ent_City_Ind.delete(0, END)
Ent_City_Ind.insert(0, resultado['cidade'].upper())
EntUf_Ind.delete(0, END)
EntUf_Ind.insert(0, resultado['uf'])
MudarStatus(False)
EntNumb_Ind.focus()
except:
messagebox.showerror("Erro Consulta CEP", "O CEP informado não é válido", parent=Windows_Cad_Ind)
EntCep1_Ind.focus()
return resultado
except:
messagebox.showinfo("SEM CONEXÃO", "ALGO DEU ERRADO", parent=Windows_Cad_Ind)
def cepForn(self):
self.entradaEndereco.delete(0, END)
self.entradaMunicipio.delete(0, END)
try:
self.cep = self.entradaCep.get()
self.endereco = pycep_correios.get_address_from_cep(self.cep)
print(self.endereco)
self.entradaEndereco.insert(END, self.endereco['logradouro'])
self.entradaEndereco.insert(END, ' - ')
self.entradaEndereco.insert(END, self.endereco['bairro'])
self.entradaMunicipio.insert(END, self.endereco['cidade'])
self.entradaMunicipio.insert(END, ' - ')
self.entradaMunicipio.insert(END, self.endereco['uf'])
except:
msg = "Cep nao encontrado"
msg += ""
messagebox.showinfo("GLAC ", msg)
def get_address_with_postal_code(self, postal_code: str):
try:
address_viacep = get_address_from_cep(postal_code,
webservice=WebService.APICEP)
return {
"street": address_viacep.get("logradouro"),
"neighborhoods": address_viacep.get("bairro"),
"city": address_viacep.get("cidade"),
"state": address_viacep.get("uf"),
}
except (exceptions.InvalidCEP, exceptions.CEPNotFound):
raise ValueError
except (
ConnectionError,
exceptions.Timeout,
exceptions.HTTPError,
exceptions.BaseException,
):
"I accepted pass here because integration exceptions with api, dont must impeditive"
pass
