I trying to make a whatsapp bot which returns a response for specifics messages
#app.route("/sms", methods=['POST'])
def sms_reply():
# Fetch the message
msg = request.form.get('Body').lower()
responded = False
if ("hola" in msg or "buenos" in msg or "buenas" in msg or "info" in msg or "holi" in msg):
reply = "Buenos días bienvenido a Alcanza soy tu asistente virtual, ¿con quien tengo el gusto?"
menu = "Por Favor, selecciona la opcion de tu preferencia: 1 Citas con asesores 2 Informacion de servicios 3 Herramientas de diagnostico 4 Servicio al cliente"
resp = MessagingResponse()
resp.message(reply)
resp.message(menu)
elif ("1" in msg):
reply = "Bienvenido al menu de citas con asesores, por favor selecciona una opcion: 1 Agendar una cita 2 Modificar una existente 3Cancelar una cita 0 Volver al menú principal"
resp = MessagingResponse()
resp.message(reply)
elif ("2" in msg):
reply = "Bienvenido al menu de informacion de servicios, por favor seleciona un servicio para recibir mas informacion: Finanzas personales 1 Asesoría de inversión 2 Webinars y capacitaciones 3 Alcanza 360 0 Volver al menú principal"
resp = MessagingResponse()
resp.message(reply)
elif ("3" in msg):
reply = "Bienvenido al menu de herramientas de diagnostico, por favor seleciona la herramienta que necesitas: 1 Cuestionario de diagnóstico financiero 2 Perfil de deuda 3 Perfil de inversión 4 Costo de tu tiempo 5 Pago de tarjeta de crédito 6 Volver al menú principal"
resp = MessagingResponse()
resp.message(reply)
return str(resp)
So I create this function and when I get the input message "1" from whatsapp the code return me a sub menu, the point is that I want to add another if statement into de principal ifs with more options, for example first input== "1" return (sub menu) and first input == "1" and second input == "1" return (option 1 of the sub menu), I tried too many times and different ifs but the code stops working or ignore the sub ifs
I'm developing a chatbot project for college, and in the following code block, the first if is always going as a true value, no matter what. I really need help and don't know what to do, cause this project is due on monday.
def registeredClient():
print('Olá, bem-vindo a WE-RJ Telecom!')
userInputString = str(input('O que você precisa?\nCaso queira contratar ou trocar de plano escreva “Quero contratar” ou “Quero trocar de plano”.\nCaso esteja com problemas de conexão, escreva "suporte".\nCaso queira seu boleto, digite "boleto":\n'))
userInputString = userInputString.lower()
if 'contratar' or 'trocar plano' or 'aumentar velocidade' or 'mudar plano' or 'velocidade' or 'plano' in userInputString:
newPlanOption()
elif 'suporte' or 'lenta' or 'internet lenta' or 'internet esta lenta' or 'problema' or 'velocidade' in userInputString:
supportOption()
elif 'boleto' or 'segunda via' or '2ª via' or 'fatura' in userInputString:
billingOption()
else:
print('Não foi posível entender a sua mensagem, seu atendimento será encerrado.')
return False
I updated the conditions. In your case your conditions were checking if the strings themselves were truthly which is why your first case would result in true.
def registeredClient():
print('Olá, bem-vindo a WE-RJ Telecom!')
userInputString = str(input('O que você precisa?\nCaso queira contratar ou trocar de plano escreva “Quero contratar” ou “Quero trocar de plano”.\nCaso esteja com problemas de conexão, escreva "suporte".\nCaso queira seu boleto, digite "boleto":\n'))
userInputString = userInputString.lower()
if any(x in userInputString for x in ['contratar', 'trocar plano' , 'aumentar velocidade' , 'mudar plano' , 'velocidade' , 'plano']):
print("Case A")
elif any(x in userInputString for x in ['suporte', 'lenta' , 'internet lenta' , 'internet esta lenta' , 'problema' , 'velocidade']):
print("Case B")
elif any(x in userInputString for x in ['boleto' , 'segunda via' , '2ª via' , 'fatura']):
print("Case C")
else:
print('Não foi posível entender a sua mensagem, seu atendimento será encerrado.')
return False
registeredClient();
The first if block is understood by python as the following if block :
(if 'contratar') or ('trocar plano') or ('aumentar velocidade') or ('mudar plano') or ('velocidade') or ('plano' in userInputString):
which is always True as the strings are not vacant and thus truthy type.
What you need is this as the first if block :
if any(i in userInputString for i in ['contratar', 'trocar plano', 'aumentar velocidade', 'mudar plano', 'velocidade', 'plano']):
Similarly you need to change your elif statements too.
Try this :
def registeredClient():
print('Olá, bem-vindo a WE-RJ Telecom!')
userInputString = str(input('O que você precisa?\nCaso queira contratar ou trocar de plano escreva “Quero contratar” ou “Quero trocar de plano”.\nCaso esteja com problemas de conexão, escreva "suporte".\nCaso queira seu boleto, digite "boleto":\n'))
userInputString = userInputString.lower()
checkString = lambda l: any(i in userInputString for i in l)
if checkString(['contratar', 'trocar plano', 'aumentar velocidade', 'mudar plano', 'velocidade', 'plano']):
newPlanOption()
elif checkString(['suporte', 'lenta', 'internet lenta', 'internet esta lenta', 'problema', 'velocidade']):
supportOption()
elif checkString(['boleto', 'segunda via', '2ª via', 'fatura']):
billingOption()
else:
print('Não foi posível entender a sua mensagem, seu atendimento será encerrado.')
return False
I have a random graph and I want to check if in this graph the nodes are connected and show which are the strongly connected items, if any
#grafo 1
grafo1=erdosRenyi(5,0.7)
def not_in(x,y):
#RODA VETOR X SOBRE Y
for i in x:
#VERIFICA SE CADA ITEM DE X ESTA EM Y, SE ESTIVE, REMOVE DO Y
if i in y:
y.remove(i)
#RETORNA SO OS ELEMENTOS RESTANTES DE Y
return y
#VETOR TOTAL DE COMPONENTES | NOS VISITADOS | TOTAL TEMPORARIO
tc = []; visitado = []; tot =0;
#EXECUTA SOBRE TODOS OS NOS
for no in grafo1:
#ADICIONA NO ATUAL AOS VISITADOS
visitado.append(no)
print('BUSCANDO PELOS VERTICES DE ', no)
#ADICIONA AO TOTAL TEMPORARIO DE NOS DO COMPONENTE
tot=tot+1
# VERIFICA SE O NO FOI VISITADO E SE ELE NAO POSSUI NOVOS ELEMENTOS PARA SEREM VISITADOS
if no in visitado and len(not_in(visitado, list(grafo1[no]))) == 0:
#CASO POSITIVO, FINALIZA O COMPONENTE
#ADICIONA UM COMPONENTE NOVO COMPONENTE AO VETOR DE COMPONENTES COMO O SEU TOTAL DE NOS
tc = tc+[tot]
#ZERA A VARIAVEL TEMPORARIA DE NOS
tot=0
print("NOVO COMPONENTE\n")
print('\nTOTAL DE COMPONENTES ',len(tc))
print('MAIOR COMPONENTE CONEXO ', max(tc))
print('TAMANHO DE TODOS OS COMPONENTES ', tc)
I'm developing the code below in a raspberry pi 4 to detect cars, but I'm having trouble "[ WARN:0#1.169] global /home/pi/opencv/modules/videoio/src/cap_gstreamer.cpp (1405) open OpenCV | GStreamer warning: Cannot query video position: status=0, value=-1, duration=-1", can anyone help me? i j tried to reinstall opencv a few times and update gstreamer but haven't had positive results yet
import cv2
import numpy as np
from datetime import date
import argparse
# Parâmetros auxiliares iniciais (fonte para textos e cores em BGR)
fonte_textos = cv2.FONT_HERSHEY_SIMPLEX
tamanho_texto = 0.4
cor_texto = (255,255,255)
cor_grade = (255,255,255)
cor_rosto = (255,255,255)
cor_linha = (96,32,0)
cor_linha_max = (80,176,0)
cor_linha_med =(0,255,255)
cor_alerta = (0,0,255)
cor_ret = (0,0,0)
hoje = str(date.today())
#variaveis auxiliares GaussianBlur
tam_kernel_gauss = (5,5)
desvio_padrao_gauus = 0
#variaveis auxiliares de posição dos textos
posicao_ret_aux = (5,5)
posicao_data = (10,20)
posicao_fps = (10,40)
posicao_distancia = (10,60)
largura_ret_aux = 8
escala_fonte = 1
posicao_dist_medida = (70, 60)
#variaveis auxiliares filtro de borda (canny)
limiar_max = 40
limiar_min = 20
razao = 2
tam_kernel_canny = apertureSize=None
#variaveis auxiliares para o detectmultiscale
fator_escala = 1.1
n_vizinhos = 1
lin_retangulo = 1
#Faz a leitura da câmera
vs = cv2.VideoCapture(0)
#Definir os classificadores
#classificador_carro = cv2.CascadeClassifier('/home/pi/Documents/classificadores/cars.xml')
classificador_carro = cv2.CascadeClassifier('/home/pi/Documents/dados/custom haar cascade/classifier/cascade.xml')
#inicializar as variáveis
#vs.set(cv2.CAP_PROP_FPS,120)
#Captura o tamanho do video (x,y)
x_do_video = int(vs.get(cv2.CAP_PROP_FRAME_WIDTH))
y_do_video = int(vs.get(cv2.CAP_PROP_FRAME_HEIGHT))
#captura do FPS
fps_video = str(vs.get(cv2.CAP_PROP_FPS))
fps_video = fps_video + " FPS"
#parametros de cálculos auxiliares
objeto_area = 0
objeto_larura = 0
objeto_altura = 0
#parametros para localizar a distância focal
#distância(em cm) da câmera ao objeto durante a captura da imagem de referência
distancia_conhecida = 50.00
#largura de um objeto do mundo real (utilizar frente do carro)
largura_real = 14.00
def distancia_foco(distancia_conhecida,largura_real,largura_pixels):
"""Funcao utilizada para capturar a distancia focal, onde:
\n :distancia_conhecida=distância da câmera ao objeto durante a captura da imagem de referência
\n :largura_real = largura de um objeto do mundo real (utilizar frente do carro)
\n :largura_pixels = largura do retangulo que ficará no frame (pixels)(w)"""
distancia_focal = (largura_pixels*distancia_conhecida)/largura_real
return distancia_focal
def medir_distancia(retorno_dist_focal,largura_real_ref,largura_pixels_ref):
"""Função utilizada para medir a distancia da lente até o objeto
\n :retorno_dist_focal = retorno da função distancia_foco
\n :largura_real_ref = largura de um objeto do mundo real (utilizar frente do carro)
\n :largura_pixels_ref = largura do retangulo que ficará no frame (pixels)(w)"
\n :todas as distancias sao dadas em centimetros"""
distancia_real = (largura_real_ref*retorno_dist_focal)/largura_pixels_ref
return distancia_real
def dados_objeto(frame):
"""Função utilizada para retornar a largura em pixels do objeto
/n :frame = imagem desejada"""
#largura do retangulo que ficará no frame (pixels)
largura_pixels = 0
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
faces = classificador_carro.detectMultiScale(frame,1.01,3)
for (x,y,w,h) in faces:
cv2.rectangle(frame, (x,y), ((x+w),(y+h)),cor_rosto, lin_retangulo)
largura_pixels = w
return largura_pixels
#carrega a imagem de referência
img_referencia = cv2.imread("/home/pi/Documents/dados/img_ref/img_46.jpg")
#encontrar a larura em pixels do objeto
largura_obj_ref = dados_objeto(img_referencia)
print(largura_obj_ref)
#encontrar a distancia focal da imagem de referencia
distancia_focal_ref = distancia_foco(distancia_conhecida, largura_real, largura_obj_ref)
# Funções auxiliares para o tratamento da imagem
def aplicar_filtros_imagem(frame):
"""Utilize esta função para tratar a imagem desejada, \n
primeiro a imagem será convertida para uma escala de cinza (cvtColor),\n
o segundo passo é aplicar um filtro passa baixa para remover os ruidos da imagem (GaussianBlur),\n
depois é aplicado uma metodologia para encontrar o limiar adaptativo (adaptiveThreshold)\n
e posteriormente é aplicado um filtro para detectar as bordas da imagem"""
#converte para escala de cinza
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
#equaliza os tons de cinza
frame = cv2.equalizeHist(frame)
#aplica o filtro passa baixa - desfoca a imagem para remover os ruídos, GaussianBlur(imagem,matriz que representa o tamanho do kernel,desvio padrão do kernel gaussiano)
frame = cv2.GaussianBlur(frame, tam_kernel_gauss, desvio_padrao_gauus)
#filtro para encontrar o limiar adaptativo,adaptiveThreshold(imagem,valor máximo=255, ADAPTIVE_THRESH_MEAN_C ou ADAPTIVE_THRESH_GAUSSIAN_C,tipo de limite,vizinhos,constante)
#frame = cv2.adaptiveThreshold(frame,255,cv2.ADAPTIVE_THRESH_GAUSSIAN_C,cv2.THRESH_BINARY,11,2)
#Filtro para detecar as bordas da imagem e também remover os ruidos. Canny(imagem, limite inferior no limite de histerese, limite superior no limite de histerese)
#frame = cv2.Canny(frame, limiar_min, int(limiar_max*razao))#,tam_kernel_canny,L2gradient=None)
#filtro para aplicar a máscara de detecção de movimento
#frame = backSub.apply(frame)
return frame
def inserir_grade(frame):
"""Utilize esta função para inserir a grade auxilia na imagem,\n
esta grade será utilizada para auxiliar na localização do objeto,\n
:frame = imagem que deseja inserir as linhas"""
cont = 0
x_aux = int(x_do_video/4)
cstx = x_aux
y_aux = int(y_do_video/4)
csty = y_aux
while cont < 5:
cv2.line(frame,(x_aux,0),(x_aux,y_do_video),cor_grade,1)
cv2.line(frame,(0,y_aux),(x_do_video,y_aux),cor_grade,1)
cont +=1
x_aux = x_aux + cstx
y_aux = y_aux + csty
return frame
def inserir_linhas(frame):
"""Utilize esta função para inserir as linhas auxiliares na imagem,\n
estas linhas serão utilizadas para medir a distância em que o objeto se encontrar,\n
:frame = imagem que deseja inserir as linhas"""
x_aux = int(x_do_video/4)
y_aux = int(y_do_video/4)
#definição do limite aceitável
#linha lado esquerdo
cv2.line(frame,(int(x_aux-x_aux/4),y_do_video-2*y_aux+int(y_aux/2)),(x_aux,y_aux),cor_linha_max,cv2.LINE_4)
#linha lado direito
cv2.line(frame,(x_do_video-int(x_aux-x_aux/4),y_do_video-2*y_aux+int(y_aux/2)),(x_do_video-x_aux,y_aux),cor_linha_max,cv2.LINE_4)
#linha horizontal
cv2.line(frame,(x_aux,y_aux),(x_do_video-x_aux,y_aux),cor_linha_max,cv2.LINE_4)
#texto
cv2.putText(frame, "Distancia aceitavel",(x_aux+int(x_aux/12),y_aux+int(y_aux/6)), fonte_textos, tamanho_texto, cor_texto,escala_fonte,cv2.LINE_AA)
return frame
def preparar_frame(frame):
"""Utilize esta função para preparar a imagem para ser analizada,\n
:frame = imagem que deseja tratar"""
frame = aplicar_filtros_imagem(frame)
#frame = inserir_grade(frame)
#frame = inserir_linhas(frame)
return frame
while True:
ret, frame = vs.read()
if frame is None:
break
largura_pixels_ref = dados_objeto(frame)
carros = classificador_carro.detectMultiScale(frame,fator_escala,n_vizinhos)
frame = preparar_frame(frame)
for (x,y,w,h) in carros:
cv2.rectangle(frame, (x,y),(x+w,y+h),cor_grade,lin_retangulo)
if largura_pixels_ref != 0:
distancia = medir_distancia(distancia_focal_ref, largura_real, largura_pixels_ref)
cv2.putText(frame, f" {round(distancia,2)} cm",posicao_dist_medida,fonte_textos,tamanho_texto, cor_texto,1,cv2.LINE_AA)
#mostra a imagem em tempo real
cv2.imshow("Video em tempo real", frame)
#sair do loop se pressionar q(quit)
if cv2.waitKey(1) == ord("q"):
print("Video interrompido")
break
#fechar a camera
vs.release()
#fechar o video aberto
cv2.destroyAllWindows()
I am writing a code to solve second-grade equations and it works just well.
However, when I input the following equation:
x^2 + (10^(20) + 10^(-20)) + 1 = 0
(Yes, my input is 10**20 + 10**(-20)
I get:
x1 = 0 x2 = -1e+20
However, it is taking (10^(20) + 10^(-20) as 10e+20 while, if you do the math:
Here is the LaTeX formatted formula:
Which is almost 10^20 but not 10^20.
How can I get the exact result of that operation so I can get the exact value of the equation in x2?
My code is the following:
#===============================Función para obtener los coeficientes===============================
#Se van a anidar dos funciones. Primero la de coeficientes, luego la de la solución de la ecuación.
#Se define una función recursiva para obtener los coeficientes de la ecuación del usuario
def cof():
#Se determina si el coeficiente a introducir es un número o una cadena de operaciones
op = input("Si tu coeficiente es un número introduce 1, si es una cadena de operaciones introduce 2")
#Se compara la entrada del usuario con la opción.
if op == str(1):
#Se le solicita el número
num = input("¿Cuál es tu número?")
#Se comprueba que efectívamente sea un número
try:
#Si la entrada se puede convertir a flotante
float(num)
#Se establece el coeficiente como el valor flotante de la entrada
coef = float(num)
#Se retorna el valor del coeficiente
return coef
#Si no se pudo convertir a flotante...
except ValueError:
#Se le informa al usuario del error
print("No introdujiste un número. Inténtalo de nuevo")
#Se llama a la función de nuevo
return cofa()
#Si el coeficiente es una cadena (como en 10**20 + 10**-20)
elif op == str(2):
#La entrada se establece como la entrada del usuario
entrada = input("Input")
#Se intenta...
try:
#Evaluar la entrada. Si se puede...
eval(entrada)
#El coeficiente se establece como la evaluación de la entrada
coef = eval(entrada)
#Se regresa el coeficiente
return coef
#Si no se pudo establecer como tal...
except:
#Se le informa al usuario
print("No introdujiste una cadena de operaciones válida. Inténtalo de nuevo")
#Se llama a la función de nuevo
return cofa()
#Si no se introdujo ni 1 ni 2 se le informa al usuario
else:
#Se imprime el mensaje
print("No introdujiste n ni c, inténtalo de nuevo")
#Se llama a la función de nuevo
return cof()
#===============================Función para resolver la ecuación===============================
#Resuelve la ecuación
def sol_cuadratica():
#Se pide el valor de a
print("Introduce el coeficiente para a")
#Se llama a cof y se guarda el valor para a
a = cof()
#Se pide b
print("Introduce el coeficiente para b")
#Se llama cof y se guarda b
b = cof()
#Se pide c
print("Introduce el coeficiente para c")
#Se llama cof y se guarda c
c = cof()
#Se le informa al usuario de la ecuación a resolver
print("Vamos a encontrar las raices de la ecuación {}x² + {}x + {} = 0".format(a, b, c))
#Se analiza el discriminante
discriminante = (b**2 - 4*a*c)
#Si el discriminante es menor que cero, las raices son complejas
if discriminante < 0:
#Se le informa al usuario
print("Las raices son imaginarias. Prueba con otros coeficientes.")
#Se llama a la función de nuevo
return sol_cuadratica()
#Si el discriminante es 0, o mayor que cero, se procede a resolver
else:
#Ecuación para x1
x1 = (-b + discriminante**(1/2))/(2*a)
#Ecuación para x2
x2 = (-b - discriminante**(1/2))/(2*a)
#Se imprimen los resultados
print("X1 = " + str(x1))
print("X2 = " + str(x2))
sol_cuadratica()
Ignore the comments, I'm from a Spanish-speaking country.
The limitations of the machine floating point type is the reason why when adding a very small number to a very big number, the small number is just ignored.
This phenomenon is called absorption or cancellation.
With custom floating point objects (like the ones decimal module) you can achieve any precision (computations are slower, because floating point is now emulated, and not relying on the machine FPU capabilities anymore)
From the decimal module docs:
Unlike hardware based binary floating point, the decimal module has a user alterable precision (defaulting to 28 places) which can be as large as needed for a given problem
This can be achieved by changing the following global parameter decimal.getcontext().prec
import decimal
decimal.getcontext().prec = 41 # min value for the required range
d = decimal.Decimal(10**20)
d2 = decimal.Decimal(10**-20)
now
>>> d+d2
Decimal('100000000000000000000.00000000000000000001')
As suggested in comments, for the small number it's safer to let decimal module handle the division by using power operator on an already existing Decimal object (even if here, the result is the same):
d2 = decimal.Decimal(10)**-20
So you can use decimal.Decimal objects for your computations instead of native floats.