示例#1
0
    def get_knowledge_graphs():
        """Retrieves Knowledge Graphs from Synthesys"""
        SynicAPI.check_connection()

        try:
            r = requests.get(SynicAPI.synic_api_url('kb'))

            if r.status_code == 200:
                response = r.json()

                kg_list = []

                for kg in response:
                    name = kg.get('name')
                    if name is not None:
                        kg_list.append(name)

                log.debug('Synic API /kb response', extra=kg_list)
                return kg_list

            else:

                raise Exception('Synic API List Knowledge Graphs request returned code {}'.format(r.status_code))

        except Exception as e:
            print(str(e))
            raise e
示例#2
0
    def check_connection():
        """Checks Synthesys Connection"""
        try:
            r = requests.get(SynicAPI.synic_api_url('app'))

            if r.status_code == 200:
                response = r.json()
                log.debug('Synic API Version: {}'.format(response.get('version')))
                return response

            else:
                raise Exception('Synic API connection health check returned code {}'.format(r.status_code))

        except Exception as e:
            print(str(e))
            raise e
示例#3
0
    def get_applications():
        """Retrieves Synthesys Application list"""
        SynicAPI.check_connection()

        try:
            r = requests.get(SynicAPI.synic_api_url('application'))

            if r.status_code == 200:
                response = r.json()
                applications = {a['name']:a for a in response}
                log.debug('Synic API /application count: {}'.format(len(applications)))
                return applications

            else:
                raise Exception('Synic API List Applications request returned code {}'.format(r.status_code))

        except Exception as e:
            print(str(e))
            raise e
示例#4
0
文件: database.py 项目: jrgoulet/enti
    def initialize_settings():
        """Initializes application settings"""
        log.debug('Initializing application settings')
        with session_scope() as session:
            for setting in ApplicationDefaults.list():
                try:
                    existing_setting = Query.Setting.get(session, setting.id)

                    if existing_setting is None:
                        log.debug('Initializing application default: {} -> {}'.format(setting.id, setting.safe_value()))
                        session.add(setting)
                    else:
                        log.debug(
                            'Application default exists: {} -> {}'.format(setting.id, setting.safe_value()))
                except Exception as e:
                    log.error('Failed to initialize setting: {} due to: {}'.format(setting.id, str(e)))
        log.debug('Application setting initialization complete')
示例#5
0
文件: database.py 项目: jrgoulet/enti
    def initialize_attributes():
        """Initializes default attributes"""
        log.debug('Initializing attribute defaults')
        with session_scope() as session:
            attr_templates = load_yml(FileConfig.ATTR_SCHEMA_FILE)

            for attr_id, attr_template in attr_templates.items():
                try:
                    attribute = Attribute(id=attr_id,
                                          name=attr_template['name'],
                                          required=attr_template.get('required', False),
                                          arity=attr_template['arity'],
                                          ko_name=attr_template['ko_name'],
                                          description=attr_template['description'],
                                          type=attr_template['type'])
                    attribute_existing = Query.Attribute.get(session, attr_id)

                    if attribute_existing is None:
                        log.debug('Initializing attribute: {}'.format(attribute.name))
                        session.add(attribute)

                    # else:
                    #     log.debug('Attribute exists, skipping: {}'.format(attribute.name))

                    for field_id in attr_template['fields']:
                        attr_field = Query.AttributeField.get(session, field_id)

                        if attr_field is not None:
                            linked_attr_field = LinkedAttributeField(attribute.id, attr_field.id)
                            linked_attr_field_existing = Query.LinkedAttributeField.get(session, linked_attr_field.id)

                            if linked_attr_field_existing is None:
                                log.debug('Creating linked attribute field {} for attribute {}'.format(attr_field.name,
                                                                                                       attribute.name))
                                session.add(linked_attr_field)
                        else:
                            log.error('Attribute field {} is not defined in field definitions. Please add field to '
                                      'enumeration located in definitions.py. Skipping for now.'.format(field_id))
                except Exception as e:
                    log.error('Failed to initialize attribute: {} due to: {}'.format(attr_id, str(e)))
        log.debug('Attribute initialization complete')
示例#6
0
文件: database.py 项目: jrgoulet/enti
    def initialize_entity_schema():
        """Initializes entity schema"""
        log.debug('Initializing entity schema defaults')
        with session_scope() as session:
            for defaults in AttributeTypes.list(), EntityTypes.list(), ArityTypes.list(), AttributeFields.list():
                for default in defaults:
                    def_type = type(default)
                    try:
                        def_existing = session.query(def_type).get(default.id)

                        if def_existing is None:
                            log.debug('Initializing default {}: {}'.format(def_type.__name__, default.name))
                            session.add(default)
                        # else:
                        #     log.debug('Entry exists for {}: {}'.format(def_type.__name__, default.name))
                    except Exception as e:
                        log.error(
                            'Failed to add default {}: {} due to: {}'.format(def_type.__name__, default.name, str(e)))
                        session.rollback()
        log.debug('Entity initialization complete')
示例#7
0
    def ingest(kg_name, test=False):
        """Ingests an exported Entities XML file into Synthesys

        :param kg_name: Name of the Knowledge Graph to ingest into
        :param test: Test parameter used to bypass function
        :return: Task ID of the resulting process
        """
        export_filename = os.path.join(AppConfig.INSTALL_DIR, AppConfig.RELATIVE_EXPORT_DIR)
        log.debug('Absolute path of export file on host machine: {}'.format(export_filename))

        if not SynicAPI.has_ee_pipeline():
            raise Exception('Synthesys instance is missing the External Entity Pipeline')

        params = {
            'kb': kg_name,
            'processType': 'jet',
            'application': SynicAPI.EE_PIPELINE_NAME,
            'invocationConfig': {
                'input': export_filename,
                'schemaResource': SynicAPI.ENTITY_SCHEMA_ENGINE,
                'kgName': kg_name
            }
        }

        log.debug('Ingestion params', extra=params)
        log.debug('Ingestion URL: {}'.format(SynicAPI.synic_api_url('process', exclude_auth=True)))

        if test:
            log.debug('*** API Request to /process endpoint is being simulated ***')
            response = {
                "id": "test-request",
                "kb": kg_name,
                "application": "externalEntityPipeline",
                "applicationReadableName": "externalEntityPipeline",
                "processType": "jet",
                "username": AppConfig.SYNTHESYS_USER,
                "requestedTime": "2018-04-16T19:47:39.563Z",
                "startedTime": None,
                "completedTime": None,
                "status": "PENDING",
                "steps": [],
                "failure": None,
                "invocationConfig": {
                    "input": export_filename,
                    "schemaResource": SynicAPI.ENTITY_SCHEMA_ENGINE,
                    "kgName": kg_name
                },
                "stackTrace": None,
                "allowedCommands": [
                    "CANCEL",
                    "CANCEL"
                ],
                "issuedCommand": None
            }
        else:
            r = requests.post(SynicAPI.synic_api_url('process', exclude_auth=True), json=params, auth=HTTPBasicAuth(
                AppConfig.SYNTHESYS_USER, AppConfig.SYNTHESYS_PASS
            ))
            if r.status_code == 200:
                response = r.json()
            else:
                raise Exception('Synic API EE Ingestion request returned code {}'.format(r.status_code))

        task_id = response.get('id')
        if task_id is None:
            raise Exception('Synic API EE Ingestion response is missing Task ID')

        extra = {
            'request': params,
            'response': response,
            'task_id': task_id
        }

        log.debug('Synic API /process request', extra=extra)

        return task_id
示例#8
0
 def has_ee_pipeline():
     """Checks Synthesys for External Entity Pipeline"""
     applications = SynicAPI.get_applications()
     is_present = applications.get(SynicAPI.EE_PIPELINE_NAME) != None
     log.debug('EE Pipeline is present: {}'.format(is_present))
     return is_present