Esempio n. 1
0
def provider_method_wrapper(tiid, input_aliases_dict, provider, method_name):

    # logger.info(u"{:20}: in provider_method_wrapper with {tiid} {provider_name} {method_name} with {aliases}".format(
    #    "wrapper", tiid=tiid, provider_name=provider.provider_name, method_name=method_name, aliases=input_aliases_dict))

    provider_name = provider.provider_name
    worker_name = provider_name+"_worker"

    if isinstance(input_aliases_dict, list):
        input_aliases_dict = item_module.alias_dict_from_tuples(input_aliases_dict)    

    input_alias_tuples = item_module.alias_tuples_from_dict(input_aliases_dict)
    method = getattr(provider, method_name)

    try:
        method_response = method(input_alias_tuples)
    except ProviderError, e:
        method_response = None

        logger.info(u"{:20}: **ProviderError {tiid} {method_name} {provider_name}, Exception type {exception_type} {exception_arguments}".format(
            worker_name, 
            tiid=tiid, 
            provider_name=provider_name.upper(), 
            method_name=method_name.upper(), 
            exception_type=type(e).__name__, 
            exception_arguments=e.args))
Esempio n. 2
0
    def wrapper(cls, tiid, input_aliases_dict, provider, method_name,
                aliases_providers_run, callback):
        #logger.info(u"{:20}: **Starting {tiid} {provider_name} {method_name} with {aliases}".format(
        #    "wrapper", tiid=tiid, provider_name=provider.provider_name, method_name=method_name, aliases=aliases))

        provider_name = provider.provider_name
        worker_name = provider_name + "_worker"

        input_alias_tuples = item_module.alias_tuples_from_dict(
            input_aliases_dict)
        method = getattr(provider, method_name)

        try:
            method_response = method(input_alias_tuples)
        except ProviderError:
            method_response = None
            logger.info(
                u"{:20}: **ProviderError {tiid} {method_name} {provider_name} "
                .format(worker_name,
                        tiid=tiid,
                        provider_name=provider_name.upper(),
                        method_name=method_name.upper()))

        if method_name == "aliases":
            # update aliases to include the old ones too
            aliases_providers_run += [provider_name]
            if method_response:
                new_aliases_dict = item_module.alias_dict_from_tuples(
                    method_response)
                new_canonical_aliases_dict = item_module.canonical_aliases(
                    new_aliases_dict)
                response = item_module.merge_alias_dicts(
                    new_canonical_aliases_dict, input_aliases_dict)
            else:
                response = input_aliases_dict
        else:
            response = method_response

        logger.info(
            u"{:20}: /biblio_print, RETURNED {tiid} {method_name} {provider_name} : {response}"
            .format(worker_name,
                    tiid=tiid,
                    method_name=method_name.upper(),
                    provider_name=provider_name.upper(),
                    response=response))

        callback(tiid, response, method_name, aliases_providers_run)

        try:
            del thread_count[provider_name][tiid + method_name]
        except KeyError:  # thread isn't there when we call wrapper in unit tests
            pass

        return response
Esempio n. 3
0
    def wrapper(cls, tiid, input_aliases_dict, provider, method_name, aliases_providers_run, callback):
        # logger.info(u"{:20}: **Starting {tiid} {provider_name} {method_name} with {aliases}".format(
        #    "wrapper", tiid=tiid, provider_name=provider.provider_name, method_name=method_name, aliases=aliases))

        provider_name = provider.provider_name
        worker_name = provider_name + "_worker"

        input_alias_tuples = item_module.alias_tuples_from_dict(input_aliases_dict)
        method = getattr(provider, method_name)

        try:
            method_response = method(input_alias_tuples)
        except ProviderError:
            method_response = None
            logger.info(
                u"{:20}: **ProviderError {tiid} {method_name} {provider_name} ".format(
                    worker_name, tiid=tiid, provider_name=provider_name.upper(), method_name=method_name.upper()
                )
            )

        if method_name == "aliases":
            # update aliases to include the old ones too
            aliases_providers_run += [provider_name]
            if method_response:
                new_aliases_dict = item_module.alias_dict_from_tuples(method_response)
                new_canonical_aliases_dict = item_module.canonical_aliases(new_aliases_dict)
                response = item_module.merge_alias_dicts(new_canonical_aliases_dict, input_aliases_dict)
            else:
                response = input_aliases_dict
        else:
            response = method_response

        logger.info(
            u"{:20}: /biblio_print, RETURNED {tiid} {method_name} {provider_name} : {response}".format(
                worker_name,
                tiid=tiid,
                method_name=method_name.upper(),
                provider_name=provider_name.upper(),
                response=response,
            )
        )

        callback(tiid, response, method_name, aliases_providers_run)

        try:
            del thread_count[provider_name][tiid + method_name]
        except KeyError:  # thread isn't there when we call wrapper in unit tests
            pass

        return response
Esempio n. 4
0
 def test_alias_tuples_from_dict(self):
     aliases = {"unknown_namespace":["myname"]}
     alias_tuples = item_module.alias_tuples_from_dict(aliases)
     assert_equals(alias_tuples, [('unknown_namespace', 'myname')])
Esempio n. 5
0
 def test_alias_tuples_from_dict(self):
     aliases = {"unknown_namespace":["myname"]}
     alias_tuples = item_module.alias_tuples_from_dict(aliases)
     assert_equals(alias_tuples, [('unknown_namespace', 'myname')])