def get_testcase(mode="smoke"):
mode_lower = mode.lower()
if mode_lower in ("smoke", "config", "demo"):
mongo = MongoDB()
return mongo.get_testcases_from_mongo(mode_lower)
elif mode == "all":
global test_cases
test_case_dir = get_testcase_dir()
all_folders = os.listdir(test_case_dir)
all_case_files = []
for folder in all_folders:
sub_test_case_dir = test_case_dir + os.sep + folder
if os.path.isdir(sub_test_case_dir):
all_case_files.append({folder: os.listdir(sub_test_case_dir)})
all_case_module = deepcopy(all_case_files)
for item in all_case_module:
for product in item:
for case in item[product]:
if ".pyc" not in case and "__init__.py" not in case:
get_testcase_from_module(product, case)
return test_cases
else:
print_log(
"Cannot recognize mode '%s', please take a double check!" % mode,
"error")
sys.exit(-1)
def get_testcase(mode="smoke"):
mode_lower = mode.lower()
if mode_lower in ("smoke", "config", "demo"):
mongo = MongoDB()
return mongo.get_testcases_from_mongo(mode_lower)
elif mode == "all":
global test_cases
test_case_dir = get_testcase_dir()
all_folders = os.listdir(test_case_dir)
all_case_files = []
for folder in all_folders:
sub_test_case_dir = test_case_dir + os.sep + folder
if os.path.isdir(sub_test_case_dir):
all_case_files.append({folder: os.listdir(sub_test_case_dir)})
all_case_module = deepcopy(all_case_files)
for item in all_case_module:
for product in item:
for case in item[product]:
if ".pyc" not in case and "__init__.py" not in case:
get_testcase_from_module(product, case)
return test_cases
else:
print_log("Cannot recognize mode '%s', please take a double check!"
% mode,
"error")
sys.exit(-1)
def consultar_informacion(self, consulta =''):
# conecta a la base de datos y trae toda la informacion guardada
conexion, coleccion, coleccion_clasificador, coleccion_prediccion = MongoDB().conexion_mongoDB()
if(consulta != ''):
coleccion = coleccion_clasificador
data_set_completo = pd.DataFrame(list(coleccion.find()))
conexion.close()
return data_set_completo
def init_data(self):
"""
:summary: Initialize test data for each test case
:param : None
:return: Test data dictionary of the current test case
"""
project = str(self.__module__).split(".")[-2]
module_name = str(self.__module__).split(".")[-1]
test_case = str(self.__class__.__name__)
mongo = MongoDB()
return mongo.find_data(
project=project, module=module_name, case=test_case
)
def __init__(self, config):
self.config = config
self.db = MongoDB(config.mongo.db, config.mongo.url, config.mongo.port)
self.host = config.api.host
self.port = config.api.port
self.web_server = DashServer(self)
def init_data(self):
"""
:summary: Initialize test data for each test case
:param : None
:return: Test data dictionary of the current test case
"""
project = str(self.__module__).split(".")[-2]
module_name = str(self.__module__).split(".")[-1]
test_case = str(self.__class__.__name__)
mongo = MongoDB()
testcase_data = mongo.find_data(
project=project, module=module_name, case=test_case
)
global_data = mongo.find_data(type_="global", project=project)
if global_data:
return dict(global_data, **testcase_data)
else:
print(testcase_data)
return testcase_data
def test_one_game(self):
uri = env['CDIO_MONGO_PASS']
db = MongoDB(uri)
images = [
im.get(f'resources/onegame/{x}')
for x in sorted(listdir('resources/onegame'))
]
for img in images:
#im.show(img)
gamestate = im.gamestate_from_board(db, img)
jsonn = gamestate.json()
print(json.dumps(jsonn, indent=2))
def entrenar_modelo(self, columna_decision, nombre_columna_binarizada,
split):
# guarda los datasets recuperados y filtrados
listado_datasets, listado_nombres_columnas = self.recuperar_informacion_dataset(
columna_decision, nombre_columna_binarizada)
datos_para_entrenamiento = self.fraccionar_datos_de_entrenamiento(
listado_datasets, listado_nombres_columnas,
nombre_columna_binarizada, split)
lista_resultados = []
for i in range(len(listado_datasets)):
for j in range(len(CLASIFICADORES)):
mc = ModelosML().obtener_mejor_clasificador(
CLASIFICADORES[j], datos_para_entrenamiento[i], '')
lista_resultados.append(mc)
conexion, _, coleccion_clasificador, _ = MongoDB().conexion_mongoDB()
nombre_clasificador_entrenado = ''
mejor_clasificador = ''
valor = 0
for i in range(len(lista_resultados)):
if (lista_resultados[i]['evaluacion_clasificador'] > valor):
mejor_clasificador = lista_resultados[i]['clasificador']
nombre_clasificador_entrenado = lista_resultados[i][
'nombre_clasificador_entrenado']
lista_dataframes = [
pd.DataFrame({
'Clasificadores Evaluados': [CLASIFICADORES],
'mejor_clasificador': [mejor_clasificador],
'nombre_clasificador_entrenado':
nombre_clasificador_entrenado,
'lista_nombre_componentes_principales':
[listado_nombres_columnas],
'fecha': [str(datetime.now())]
})
]
# guarda la informacion en base de datos del mejor clasificador en este entrenamiento
datos_en_BD = AccesoDB().guardar_datos(lista_dataframes, conexion,
coleccion_clasificador)
return lista_resultados
def procesar_informacion(self, directorio_archivo,
nombre_columna_binarizada, columna_decision,
limite_binarizacion):
df_original = self.crear_dataframe_original(directorio_archivo,
nombre_columna_binarizada,
columna_decision,
limite_binarizacion)
lista_dataframes = self.crear_dataframes_procesados(df_original)
conexion, coleccion, _, _ = MongoDB().conexion_mongoDB()
# guarda la informacion en base de datos
datos_en_BD = AccesoDB().guardar_datos(lista_dataframes, conexion,
coleccion)
return datos_en_BD
def __init__(self):
uri = os.environ['CDIO_MONGO_PASS']
self.db = MongoDB(uri)
from cvengine.edge import CVEngine
from cvengine import serializer as im
from database.mongo import MongoDB
app = FastAPI()
origins = ["*"]
app.add_middleware(
CORSMiddleware,
allow_origins=origins,
allow_credentials=True,
allow_methods=["*"],
allow_headers=["*"],
)
db = MongoDB(env['CDIO_MONGO_PASS'])
cv = CVEngine
@app.post('/upload/')
async def upload(file: UploadFile = File(...)):
img = im.save(im.load(file.file))
return StreamingResponse(img, media_type='image/jpg')
@app.post('/board/')
async def upload(file: UploadFile = File(...)):
gamestate = cv.gamestate_from_board(db, im.load(file.file))
return JSONResponse(content=gamestate.json())
def predecir(self, directorio_archivo, nombre_columna_binarizada,
columna_decision, limite_binarizacion,
coleccion_clasificador):
# carga la informacion de la base de datos del mejor clasificador, los componentes principales, mejor modelo entrenado
datos_en_db = AccesoDB().consultar_informacion('mejorclasificador')
tamano_lista_clasificadores = list(datos_en_db.shape)[0]
ultimo_mejor_clasificador = datos_en_db['mejor_clasificador'][
tamano_lista_clasificadores - 1]
# lee el nombre del clasificador con que se realizara la prediccion
nombre_clasificador_entrenado = datos_en_db[
'nombre_clasificador_entrenado'][tamano_lista_clasificadores - 1]
# obtirnr los componentes principales del ultimo mejor clasificador
listado_componentes_principales = datos_en_db[
'lista_nombre_componentes_principales'][tamano_lista_clasificadores
- 1]
# obtengo solo las columnas que no son objetivo
listado_nombres_columnas = [
i for i in listado_componentes_principales
if i != nombre_columna_binarizada
]
# fue el dataset que se quiere validar para prediccion
data_original = self.crear_dataframe_original(
directorio_archivo, nombre_columna_binarizada, columna_decision,
limite_binarizacion)
data_subida_para_prediccion = data_original.filter(
listado_nombres_columnas, axis=1)
# realiza pretratamiento de data, no acepta columnas con datos vacios
data_subida_para_prediccion = data_subida_para_prediccion.dropna()
# se ubica en el directorio donde estan los clasificadores entrenados
os.chdir(DIRECTORIO_MODELOS)
# carga el mejor clasificador para predecir la data
clasificador_entrenado = joblib.load(nombre_clasificador_entrenado)
# retorna al directorio principal del proyecto
os.chdir(DIRECTORIO_ARCHIVOS)
# obtiene los datos predecidos
datos = clasificador_entrenado.predict(data_subida_para_prediccion)
# reemplazo los valores numericos por etiquetas para la predccion
datos = list(
map(lambda x: 'BAJA HUMEDAD' if x == 0 else 'ALTA HUMEDAD', datos))
# crea el dataframe que se va a guardar con todo lo que se uso para la prediccion
lista_dataframes = [
pd.DataFrame({
'Clasificador':
ultimo_mejor_clasificador,
'listado_componentes_principales':
[listado_componentes_principales],
'nombre_clasificador_entrenado_usado':
nombre_clasificador_entrenado,
'Prediccion': [datos],
'Cantidad de Datos Cargados': [{
'Filas':
data_original.shape[0],
'Columnas':
data_original.shape[1]
}],
'data_procesada_para_prediccion':
[data_subida_para_prediccion],
'fecha': [str(datetime.now())]
})
]
# guarda la informacion en base de datos del mejor clasificador en este entrenamiento
conexion, _, _, coleccion_prediccion = MongoDB().conexion_mongoDB()
datos_en_BD = AccesoDB().guardar_datos(lista_dataframes, conexion,
coleccion_prediccion)
print('Prediccion API ', datos)
# retorna la prediccion del dataset
return datos
def _load_config():
location = os.path.realpath(
os.path.join(os.getcwd(), os.path.dirname(__file__)))
location = str(location)
try:
with open(location + '/config.yml', 'r') as yamlfile:
cfg = yaml.load(yamlfile)
except EnvironmentError:
_log.critical("Can't find config file", exc_info=True)
raise
return cfg
def _init_logger():
log = logging.getLogger(__file__)
log.setLevel(logging.INFO)
handler = logging.StreamHandler()
log.addHandler(handler)
return log
if __name__ == '__main__':
_log = _init_logger()
_config = _load_config()
_db = MongoDB()
_server.run(host=_config.get('host', '0.0.0.0'),
port=_config.get('port', 5000),
debug=_config.get('debug', False))
except EnvironmentError:
_log.critical("Can't find config file", exc_info=True)
raise
return cfg
def _init_logger():
log = logging.getLogger(__file__)
log.setLevel(logging.INFO)
handler = logging.StreamHandler()
log.addHandler(handler)
return log
if __name__ == '__main__':
_log = _init_logger()
_config = _load_config()
_mongo = MongoDB()
_reddit_client = praw.Reddit(
user_agent="My cool reddit script",
log_requests=_config.get('log-requests', False),
)
try:
_log.info('Starting redditbot...')
main()
except KeyboardInterrupt:
_log.info("redditbot is shutting down...")
_log.info('reddibot is done.')
try:
consumer_key = os.environ['TWITTER_CONSUMER_KEY']
consumer_secret = os.environ['TWITTER_CONSUMER_SECRET']
access_token = os.environ['TWITTER_ACCESS_TOKEN']
access_token_secret = os.environ['TWITTER_SECRET_ACCESS_TOKEN']
env = get_env_data_as_dict('./.env')
db_user = env['DB_USERNAME']
db_passwd = env['DB_PASSWORD']
db_name = env['DB_DATABASE']
except Exception as e:
log_error('could not get env variables', e)
# connecting to db...
db = MongoDB(db_user, db_passwd, db_name)
tweets = db.get_tweets()
# if there are not tweets on db then added new ones
if len(tweets) <= 0:
log_warning('no tweets found. inserting new ones')
# tweepy configuration
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth)
search_words = ['covid', '#covid-19', '#covid19', 'lockdown']
public_tweets = api.search(q=search_words, lang='en', count=1000)
for tweet in public_tweets:
tweets.append({'text': tweet.text})
def __init__(self, config):
self.config = config
self.db = MongoDB(config.mongo.db, config.mongo.url, config.mongo.port)
