Пример #1
0
    def find_similar_reactions(cls,
                               structure,
                               is_product: Optional[bool] = None):
        """
        search reactions including similar molecules

        :param structure: CGRtools MoleculeContainer
        :param is_product: role of molecule: Reactant = False, Product = True, Any = None
        :return:ReactionSearchCache object with all found reactions or None
        """
        if not isinstance(structure, MoleculeContainer):
            raise TypeError('Molecule expected')
        elif not len(structure):
            raise ValueError('empty query')

        if is_product is None:
            role = 0
        elif isinstance(is_product, bool):
            role = 2 if is_product else 1
        else:
            raise ValueError('invalid role')

        structure = dumps(structure, compression='gzip').hex()
        schema = cls._table_[0]  # define DB schema
        ci, fnd = cls._database_.select(
            f'''SELECT * FROM "{schema}".cgrdb_search_reactions_by_molecule('\\x{structure}'::bytea, {role}, 2)'''
        )[0]
        if fnd:
            c = cls._database_.ReactionSearchCache[ci]
            c.__dict__['_size'] = fnd
            return c
Пример #2
0
def _run_job(args):
    # Reset random seed
    np.random.seed()

    synthesizer, metadata, metrics, iteration, cache_dir, \
        timeout, run_id, aws_key, aws_secret, max_rows = args

    name = synthesizer['name']
    dataset_name = metadata._metadata['name']

    LOGGER.info(
        'Evaluating %s on %s dataset %s with timeout %ss; iteration %s; %s',
        name, metadata.modality, dataset_name, timeout, iteration,
        used_memory())

    if timeout:
        output = _score_with_timeout(timeout, synthesizer, metadata, metrics,
                                     iteration)
    else:
        output = _score(synthesizer,
                        metadata,
                        metrics,
                        iteration,
                        max_rows=max_rows)

    scores = output.get('scores')
    if not scores:
        scores = pd.DataFrame({'score': [None]})
    else:
        scores = pd.DataFrame(scores)

    scores.insert(0, 'synthesizer', name)
    scores.insert(1, 'dataset', metadata._metadata['name'])
    scores.insert(2, 'modality', metadata.modality)
    scores.insert(3, 'iteration', iteration)
    scores['model_time'] = output.get('model_time')
    scores['run_id'] = run_id

    if 'error' in output:
        scores['error'] = output['error']

    if cache_dir:
        cache_dir_name = str(cache_dir)
        base_path = f'{cache_dir_name}/{name}_{dataset_name}_{iteration}_{run_id}'
        if scores is not None:
            write_csv(scores, f'{base_path}_scores.csv', aws_key, aws_secret)
        if 'synthetic_data' in output:
            synthetic_data = compress_pickle.dumps(output['synthetic_data'],
                                                   compression='gzip')
            write_file(synthetic_data, f'{base_path}.data.gz', aws_key,
                       aws_secret)
        if 'exception' in output:
            exception = output['exception'].encode('utf-8')
            write_file(exception, f'{base_path}_error.txt', aws_key,
                       aws_secret)

    return scores
Пример #3
0
def test_dump_vs_dumps(simple_dump_and_remove):
    path, compression, message, optimize = simple_dump_and_remove
    dump(
        message,
        path,
        compression=compression,
        set_default_extension=False,
        optimize=optimize,
    )
    cmp1 = dumps(message, compression=compression, arcname=path, optimize=optimize)
    with open(path, "rb") as f:
        cmp2 = f.read()
    if compression != "gzip":
        assert cmp1 == cmp2
    else:
        assert loads(cmp1, compression) == loads(cmp2, compression)
Пример #4
0
    def find_similar(cls, structure):
        """
        similarity search

        :param structure: CGRtools MoleculeContainer
        :return: MoleculeSearchCache object with all found molecules or None
        """
        if not isinstance(structure, MoleculeContainer):
            raise TypeError('Molecule expected')
        elif not len(structure):
            raise ValueError('empty query')

        structure = dumps(structure, compression='gzip').hex()
        schema = cls._table_[0]  # define DB schema
        ci, fnd = cls._database_.select(
            f'''SELECT * FROM "{schema}".cgrdb_search_similar_molecules('\\x{structure}'::bytea)'''
        )[0]
        if fnd:
            c = cls._database_.MoleculeSearchCache[ci]
            c.__dict__['_size'] = fnd
            return c
Пример #5
0
    def find_mappingless_substructures(cls, structure):
        """
        search reactions by substructures of molecules

        :param structure: CGRtools ReactionContainer
        :return: ReactionSearchCache object with all found reactions or None
        """
        if not isinstance(structure, ReactionContainer):
            raise TypeError('Reaction expected')
        elif not structure.reactants and not structure.products:
            raise ValueError('empty query')

        structure = dumps(structure, compression='gzip').hex()
        schema = cls._table_[0]  # define DB schema
        ci, fnd = cls._database_.select(
            f'''SELECT * FROM "{schema}".cgrdb_search_mappingless_substructure_reactions('\\x{structure}'::bytea)'''
        )[0]
        if fnd:
            c = cls._database_.ReactionSearchCache[ci]
            c.__dict__['_size'] = fnd
            return c
Пример #6
0
    def find_substructures(cls, structure):
        """
        substructure search

        substructure search is 2-step process. first step is screening procedure. next step is isomorphism testing.

        :param structure: CGRtools MoleculeContainer or QueryContainer
        :return: MoleculeSearchCache object with all found molecules or None
        """
        if not isinstance(structure, (MoleculeContainer, QueryContainer)):
            raise TypeError('Molecule or Query expected')
        elif not len(structure):
            raise ValueError('empty query')

        structure = dumps(structure, compression='gzip').hex()
        schema = cls._table_[0]  # define DB schema
        ci, fnd = cls._database_.select(
            f'''SELECT * FROM "{schema}".cgrdb_search_substructure_molecules('\\x{structure}'::bytea)'''
        )[0]
        if fnd:
            c = cls._database_.MoleculeSearchCache[ci]
            c.__dict__['_size'] = fnd
            return c
Пример #7
0
 def __init__(self, **kwargs):
     structure = kwargs.pop('structure')
     if not isinstance(structure, MoleculeContainer):
         raise TypeError('molecule expected')
     super().__init__(_structure=dumps(structure, compression='gzip'),
                      **kwargs)
Пример #8
0
 def __setitem__(self, key, value):
     if self.writeback:
         self.cache[key] = value
     self.dict[key.encode(self.keyencoding)] = dumps(
         value, self._compression, self._protocol, self._fix_imports,
         self._buffer_callback, self._optimize, **self._kwargs)
Пример #9
0
 def __init__(self, structure):
     """
     storing reaction in DB.
     :param structure: CGRtools ReactionContainer
     """
     super().__init__(_structure=dumps(structure, compression='gzip'))
Пример #10
0
def upload_obj(obj, bucket, object_name, compression="gzip"):
    """ Upload a Python Object to an S3 bucket. """
    buffer = cp.dumps(obj, compression=compression)
    return upload_buffer(buffer, bucket, object_name)
#3.Cliente Socket com objeto serializado com pickle sem o protobuff.
import ast, json, socket, sys, struct
from ast2json import ast2json
import compress_pickle as pickle

address = ('localhost', 6005)  #endereco do servidor
client_socket = socket.socket(socket.AF_INET,
                              socket.SOCK_DGRAM)  #parametros do socket
client_socket.connect(address)  #conectar ao servidor
list_expr = [
    "(25+8)+(9*7)/(32/8)**2", "(15-8)*3", "(5+9)*(3**2)", "15+15+15+15*3",
    "2*2*2*2*2+32", "9*9*9", "(1+2)*(3/4)"
]
for expressao in list_expr:
    expre_str_m = expressao  #Recebe a exrpessao
    ast_parse_x = ast.parse(
        expre_str_m, "",
        "eval")  #Cria o objeto ast – arvore binaria com a expressao
    sout = pickle.dumps(
        ast_parse_x, compression="gzip")  #Serializa com compressao dos dados
    client_socket.sendall(sout)  #Envia os dados serializados
    print("Expressao", expressao)  #imprime a expressao
Пример #12
0
def test_dumps_loads(random_message, compressions):
    message = random_message
    assert loads(dumps(message, compressions), compressions) == message