Example #1
0
def store_selection():
    configs = Configurations()

    store = configs.first()
    if len(configs) > 1:
        selection = raw_input('Store ID: ')
        store = int(selection) if selection else store

    config = configs.to(store)
    return store, config
Example #2
0
    def post(self):
        """SComparing similairty of faces in two different images."""
        logging.info('Received post message.')

        args = file_upload.parse_args()
        # print(args)

        if 'image' not in args['first_image'].content_type:
            logging.error('First file is not an image')
            return api.abort(
                400, 'Expecting only image files. First File is not an image.')
        if 'image' not in args['second_image'].content_type:
            logging.error('Second file is not an image')
            return api.abort(
                400,
                'Expecting only image files. Second file is not an image.')

        filename1 = os.path.join(Configurations().image_upload_folder,
                                 args['first_image'].filename)
        filename2 = os.path.join(Configurations().image_upload_folder,
                                 args['second_image'].filename)

        logging.info('Saving image files.')
        args['first_image'].save(filename1)
        logging.info('Saved {}'.format(filename1))
        args['second_image'].save(filename2)
        logging.info('Saved {}'.format(filename2))

        logging.info('Loading image files.')
        first_image = face_recognition.load_image_file(filename1)
        logging.info('Loaded first image.')
        second_image = face_recognition.load_image_file(filename2)
        logging.info('Loaded second image.')

        # dets = detector(first_image, 1)
        logging.info('Finding Facial encodings')
        first_image_encoding = face_recognition.face_encodings(first_image)
        second_image_encoding = face_recognition.face_encodings(second_image)

        if len(first_image_encoding) == 0:
            logging.error('Unable to detect face in the first image')
            api.abort(500, 'Unable to detect face in the first image')

        if len(second_image_encoding) == 0:
            logging.error('Unable to detect face in the second image')
            api.abort(500, 'Unable to detect face in the second image')
        # comparision_result = face_recognition.compare_faces([first_image_encoding], second_image_encoding)
        logging.info('Finding distance between faces.')
        face_distance = np.linalg.norm(first_image_encoding[0] -
                                       second_image_encoding[0])
        logging.info('Face distance found as {}'.format(face_distance))

        return {'similarity': 1 - face_distance}, 201
Example #3
0
class Validator :
    ''' Clase que valida el estado de distintas partes del programa. '''

    def __init__(self) :
        self.pt = PathTools()
        self.config = Configurations()


    def checkFolders (self) :
        """ Verifica que existan los directorios de la aplicación """

        # obtiene la ruta del directorio /databases
        databases_dir = self.pt.getPathDatabasesDir()

        # si no existe el directorio, lo crea
        if not os.path.exists(databases_dir) :
            print 'El directorio /databases no existia, ha sido creado nuevamente.'
            os.mkdir(databases_dir)

        # obtiene la ruta del directorio /data
        data_dir = self.pt.getPathDataDir()

        # si no existe el directorio, lo crea
        if not os.path.exists(data_dir) :
            print 'El directorio /data no existia, ha sido creado nuevamente.'
            os.mkdir(data_dir)

    def checkExistCfg (self) :
        """ Verifica la existencia del archivo de configuracion """

        existe = False
        path_cfg = self.pt.getPathCFGFile()

        if not os.path.exists(path_cfg):
            self.config.regenerateNewCFG()
            existe = True
        return existe

    def checkIntegrityCfg (self) :
        """ Verifica la integridad del archivo de configuracion """
        pass

    def check (self) :

        # verifica la existencia de los directorios
        self.checkFolders()

        # verifica la existencia del archivo de configuracion
        self.checkExistCfg()
Example #4
0
 def __init__(self):
     
     # class instances
     self._DBUtils = DBUtils()
     self._PT = PathTools()
     self._Configs = Configurations()
     
     # private instances
     self._BD = None
     # diccionario con todas las instancia de objeto Snippet
     self._Snippets = None
     # objeto snippet mostrado actualmente en GUI
     self._SnippetActual = None # Snippet
     
     # esta variable, se utilizara para saber si la instancia de 
     # snippetmanager se creo correctamente con una bd determinada
     # o se creo vacia, indicando que no se puede realizar ninguna
     # operacion sobre la aplicacion 
     self._estado = False
     
     # lista con las rutas de las base de datos
     # tanto las del pathdefault como del cfg file
     self._AllPathDBs = []
     self.loadAllPathDBs()
     
     # trae si existe, el valor de la bd a cargar por defecto
     defaultBdName = self._Configs.defaultBdName
Example #5
0
def main(_):
    config = Configurations()
    config.input_file_pattern = FLAGS.input_file_pattern
    g = tf.Graph()
    with g.as_default():
        model = Model("train", config)
        model.build()

        train_op = model.train_op


    tf.contrib.slim.learning.train(
        model.train_op,
        config.train_dir,
        log_every_n_steps=FLAGS.log_every_n_steps,
        graph=g,
        global_step=model.global_step,
        number_of_steps=FLAGS.number_of_steps,
        saver=model.saver)
Example #6
0
def main(_):
    # Build the inference graph.
    g = tf.Graph()
    with g.as_default():
        model = inference_wrapper.InferenceWrapper()
        restore_fn = model.build_graph_from_config(Configurations(),
                                                   FLAGS.checkpoint_path)
    g.finalize()

    # Create the vocabulary.
    vocab = vocabulary.Vocabulary(FLAGS.vocab_file)

    filenames = []
    for file_pattern in FLAGS.input_files.split(","):
        filenames.extend(tf.gfile.Glob(file_pattern))
    tf.logging.info("Running caption generation on %d files matching %s",
                    len(filenames), FLAGS.input_files)

    with tf.Session(graph=g) as sess:
        # Load the model from checkpoint.
        restore_fn(sess)

        # Prepare the caption generator. Here we are implicitly using the default
        # beam search parameters. See caption_generator.py for a description of the
        # available beam search parameters.
        generator = caption_generator.CaptionGenerator(model, vocab)

        for filename in filenames:
            with tf.gfile.GFile(filename, "r") as f:
                image = f.read()
            captions = generator.beam_search(sess, image)
            print("Captions for image %s:" % os.path.basename(filename))
            for i, caption in enumerate(captions):
                # Ignore begin and end words.
                sentence = [
                    vocab.id_to_word(w) for w in caption.sentence[1:-1]
                ]
                sentence = " ".join(sentence)
                print("  %d) %s (p=%f)" %
                      (i, sentence, math.exp(caption.logprob)))
Example #7
0
 def __init__(self):
     self.pt = PathTools()
     self.config = Configurations()
Example #8
0
class SnippetManagerBase:
    ''' Clase que hace de wrapper entre las clases
    de la logica del programa, con la clase Fragmentos'''

    def __init__(self):
        
        # class instances
        self._DBUtils = DBUtils()
        self._PT = PathTools()
        self._Configs = Configurations()
        
        # private instances
        self._BD = None
        # diccionario con todas las instancia de objeto Snippet
        self._Snippets = None
        # objeto snippet mostrado actualmente en GUI
        self._SnippetActual = None # Snippet
        
        # esta variable, se utilizara para saber si la instancia de 
        # snippetmanager se creo correctamente con una bd determinada
        # o se creo vacia, indicando que no se puede realizar ninguna
        # operacion sobre la aplicacion 
        self._estado = False
        
        # lista con las rutas de las base de datos
        # tanto las del pathdefault como del cfg file
        self._AllPathDBs = []
        self.loadAllPathDBs()
        
        # trae si existe, el valor de la bd a cargar por defecto
        defaultBdName = self._Configs.defaultBdName

##########################
## Metodos de instancia ##
##########################

    def agregarSnippet(self, datosSnippet):
        ''' Recibe un dicionario de los datos de lo que sera un nuevo
        snippet y lo agrega a la BD.'''
        
        # llama al metodo de bd para agregar un snippet, devolviendo
        # el resultado de la operacion como boolean y en caso de error, 
        # el mensaje del error.
        resultado, mensaje = self._BD.agregarSnippet(datosSnippet)
        if resultado:
            # crea una instancia del nuevo snippet
            newSnippet = Snippet(datosSnippet, self._BD)
            # agrega el nuevo snippet a los ya existentes
            self._addNewSnippetToCollection(newSnippet)
            # retorna que la operacion fue exitosa, 
            #  y ningun mensaje de error
            return True, None
        else:
            # retorna que la operacion no fue exitosa, y 
            # el mensaje de error devuelto por bd
            return False,mensaje

    def eliminarSnippet(self, unSnippet):
        ''' Manda a eliminarSnippet de la Bd que
        borre el snippet segun su titulo y lenguaje.'''
        
        # llama al metodo de bd para eliminar un snippet
        # y devuelve un booleano con el resultado de la operacion.
        if self._BD.eliminarSnippet(
            unSnippet.titulo, unSnippet.lenguaje):
                # quita del diccionario el snippet
                self._Snippets.pop((unSnippet.lenguaje,
                                        unSnippet.titulo))
                # establece como actual snippet a None
                self._SnippetActual = None
                return True
        else:
            return False

    def modificarSnippet(self, clave_spviejo, snippet_nuevo):
        ''' Actualiza el snippet cargado en memoria'''
        del self._Snippets[clave_spviejo]
        self._Snippets[
                (snippet_nuevo.lenguaje,snippet_nuevo.titulo)
                    ] = snippet_nuevo
    
    def newSnippet(self, tuplaSnippet):
        ''' Crea una instancia de snippet. '''
        
        # a partir de los valores que vienen en la tupla, 
        # se crea una instancia de snippet con dichos valores.
        nuevoSnippet = Snippet({
            'title':tuplaSnippet[0],
            'language':tuplaSnippet[1],
            'tags':tuplaSnippet[2],
            'contens':tuplaSnippet[3],
            'description':tuplaSnippet[4],
            'creation':tuplaSnippet[5],
            'reference':tuplaSnippet[6],
            'modified':tuplaSnippet[7],
            'uploader':tuplaSnippet[8],
            'starred':tuplaSnippet[9]},
            self._BD)
            
        # tupla que sera de clave en el diccionario de los snippets
        clave = (tuplaSnippet[1],tuplaSnippet[0])
        
        elemento_diccionario = (clave,nuevoSnippet)

        return elemento_diccionario

    def _addNewSnippetToCollection(self, newSnippet):
        ''' Agrega el nuevo snippet creado a la coleccion actual de snippets. '''
        self._Snippets.update(
            {(newSnippet.lenguaje, newSnippet.titulo):newSnippet})

#################
## Metodos Get ##
#################

    def getAllLenguajes(self):
        ''' Obtiene una lista de los lenguajes desde la bd.'''
        
        # obtiene desde la actual instancia de bd los lenguajes existentes 
        all_lenguajes = self._BD.getLenguajes()
        lenguajes = []
        # saca de la tupla y carga en la lista los lenguajes obtenidos
        #~ for lenguaje in all_lenguajes:
            #~ lenguajes.append(lenguaje[0])
        map(lambda lenguaje: lenguajes.append(lenguaje[0]), all_lenguajes)
        return lenguajes

    def getBDNames(self):
        ''' Obtiene una lista con los nombres de los archivos bds.'''
        databases_dir = self._DBUtils.getBDsNamesDatabasesDir()
        cfg_file = self._Configs.getDBsNamesCFGReferences()
        couch_dbs = [name + ' [CouchDB]'for name in self._Configs.getNamesCouch()]
        return databases_dir + cfg_file + couch_dbs
        
    def getDB(self):
        return self._BD
    
    def getAllSnippets(self):
        ''' Obtiene los snippets desde la bd y carga en un diccionario
        los snippets en formato objeto Snippet().'''
        
        # obtiene desde la bd todos los snippets,
        # orden en que vienen los campos
        # 1-title,2-language,3-tags,4-contens,5-description
        # 6-creation,7-reference,8-modified,9-uploader,10-starred
        all_snippets = self._BD.getAllSnippets()
        
        # se aplica map para crear por cada tupla obtenida desde la bd
        # una tupla de tuplas donde el formato resultante es:
        # (claveSnippet : instanciaSnippet)
        todos_los_snippets = map(self.newSnippet,all_snippets)
        
        # dict(), convierte la tupla de tuplas a diccionario
        return dict(todos_los_snippets)

    def getInstanceState(self):
        ''' '''
        return self._estado
    
    def getIndexBdName(self, bdName):
        ''' Busca en la lista de bds la ocurrencia de la primer bd que 
        coincida con el nombre del parametro <bdName>, devolviendo la 
        posicion en que se encuentra. 
        Devuelve -1 si no se encuentra. '''
        
        return self._AllPathDBs.index(bdName)
        
    def getLengsAndTitles(self,consulta=None, favorito = None):
        ''' Obtiene los snippets por lenguajes desde la bd.'''
        #~ tagsPresicion = bool(self._DBUtils.configs.searchPresitionTags)
        tagsPresicion = False
        return self._BD.getLengAndTitles(consulta, favorito, tagsPresicion)

    def getSnippet(self, lenguaje, titulo):
        ''' Obtiene un snippet por su lenguaje y titulo correspondiente. '''
        try:
            # del diccionario donde estan todas las instancias de snippet,
            # a partir de la clave tupla, recupera la instancia
            # con lenguaje y titulo indicado 
            snippet = self._Snippets[(lenguaje,titulo)]
            
            # establece como instancia actual en uso, la instancia obtenida
            self.setSnippetActual(snippet)
        except Exception, msg:
            # si el snippet no esta en el diccionario, devuelve None
            snippet = None
            self.setSnippetActual(snippet)
            print 'getSnippet Error: ',msg
        return snippet
Example #9
0
                invalid_params.append('config_template')

    if len(invalid_params) > 0:
        show_invalid_params(invalid_params, parsed_params)
        show_help(program_name, parsed_params)
        sys.exit(1)

    return parsed_params


def create_logs_path():
    logpath = os.path.join(BASE_DIR, 'logs')
    if not os.path.exists(logpath):
        log.info("Key directory doesn't exist. Making the directory ...")
        try:
            os.mkdir(logpath)
        except Exception as e:
            log.error('Error: Failed to create dir {}'.format(logpath))
            log.error('Exception occured', exc_info=True)
            sys.exit(1)


if __name__ == "__main__":
    create_logs_path()

    parsed_params = parse_cmd_parameters()

    config = Configurations(parsed_params)

    manager = Manager(config)
    manager.start()
Example #10
0
            optimizer.apply_gradients(grads_and_vars=zip(
                grads, model.variables))  # 更新参数
            if (batch + 1) % 50 == 0:
                print('[Epoch{} Batch{}] loss:{:.3f}'.format(
                    epoch + 1, batch + 1, loss.numpy()))
        manager.save()  # 每个epoch后保存一个checkpoint
        print('Epoch{} Loss: {:.5f}'.format(epoch + 1, np.mean(epoch_loss)))
        print('***************')


if __name__ == '__main__':
    train_X = np.loadtxt('/data/train_X.txt', dtype='int')
    train_Y = np.loadtxt('/data/train_Y.txt', dtype='int')
    test_X = np.loadtxt('/data/test_X.txt', dtype='int')

    index2word, word2index, embedding_matrix = load_vocab_embedding_matrix()

    config = Configurations()

    train_dataset = tf.data.Dataset.from_tensor_slices(
        (train_X, train_Y)).batch(config.batch_size)

    model = Seq2seq(vocab_size=embedding_matrix.shape[0],
                    embedding_dim=embedding_matrix.shape[1],
                    embedding_matrix=embedding_matrix,
                    gru_units=config.hid_dim,
                    dropout_rate=config.dropout)

    training(model, train_dataset, config.epochs, config.learning_rate,
             word2index['<PAD>'])
Example #11
0
"""Snake game in python"""
from pathlib import Path

import pygame
from direction import Direction
from game import Game
from configurations import Configurations

pygame.init()
pygame.display.set_caption("PySnake")
ABS_PATH = str(Path(r"images\png-snake-icon.png").absolute())
icon = pygame.image.load(ABS_PATH)
pygame.display.set_icon(icon)
clock = pygame.time.Clock()

cf = Configurations()
game = Game(cf)
win = pygame.display.set_mode(
    (cf.board_width + 1, cf.board_width + 1 + cf.cell_size * 2))

# Main game loop
while True:
    pygame.time.delay(260 - game.level * 20)
    clock.tick(40)

    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            game.quit_game()
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_RIGHT:
                game.snake.set_direction(Direction.RIGHT)