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)