ACCESS_TOKEN_SECRET, adapt_date, adapt_json, TweetSource, TweetLog, MediaType, 

    Media, EntityMedia, Entity, EntityType)

def get_oauth_token(token_file_path=None, check_access_token=True, application_name=APPLICATION_NAME, consumer_key=CONSUMER_KEY, consumer_secret=CONSUMER_SECRET):

    if 'ACCESS_TOKEN_KEY' in globals() and 'ACCESS_TOKEN_SECRET' in globals() and ACCESS_TOKEN_KEY and ACCESS_TOKEN_SECRET:

    res = CACHE_ACCESS_TOKEN.get(application_name, None)

    if res is None and token_file_path and os.path.exists(token_file_path):

        get_logger().debug("get_oauth_token : reading token from file %s" % token_file_path) #@UndefinedVariable

        res = twitter.oauth.read_token_file(token_file_path)

    if res is not None and check_access_token:

        get_logger().debug("get_oauth_token : Check oauth tokens") #@UndefinedVariable

        t = twitter.Twitter(auth=twitter.OAuth(res[0], res[1], CONSUMER_KEY, CONSUMER_SECRET))

        status = None

        try:

            status = t.account.rate_limit_status()

        except Exception as e:

            get_logger().debug("get_oauth_token : error getting rate limit status %s" % repr(e))

            status = None

        get_logger().debug("get_oauth_token : Check oauth tokens : status %s" % repr(status)) #@UndefinedVariable

        if status is None or status['remaining_hits'] == 0:

            get_logger().debug("get_oauth_token : Problem with status %s" % repr(status))

            res = None

    if res is None:

        get_logger().debug("get_oauth_token : doing the oauth dance")

        res = twitter.oauth_dance.oauth_dance(application_name, consumer_key, consumer_secret, token_file_path)

    CACHE_ACCESS_TOKEN[application_name] = res

    return res

    },

    'entities' : {

        "medias": {

            "sizes"  : adapt_json,

        },                  

        if self.instance is None:

            self.instance = self.klass(*new_args, **new_kwargs)

        else:

            self.instance = self.klass(*new_args, **new_kwargs)

            self.instance = session.merge(self.instance)

        self.__bufferdict = {}

    def __add_proxy_object(self, proxy):

        proxy_list =  self.__bufferdict.get(proxy.klass, None)

        if proxy_list is None:

            proxy_list = []

            self.__bufferdict[proxy.klass] = proxy_list

        proxy_list.append(proxy)

        self.__bufferlist.append(proxy)

    def add_object(self, klass, args, kwargs, must_flush, instance=None):

        new_proxy = ObjectBufferProxy(klass, args, kwargs, must_flush, instance)

        self.__add_proxy_object(new_proxy)

        if klass in self.__bufferdict:

            for proxy in self.__bufferdict[klass]:

                if proxy.kwargs is None or len(proxy.kwargs) == 0 or proxy.klass != klass:

                    continue

                found = True

                for k,v in kwargs.items():

                    if (k not in proxy.kwargs) or v != proxy.kwargs[k]:

                        found = False

                        break

                if found:

                    return proxy        

    def __init__(self, json_dict, json_txt, source_id, session, access_token=None, token_filename=None):

        self.access_token = access_token

    def __get_user(self, user_dict, do_merge, query_twitter = False):

        get_logger().debug("Get user : " + repr(user_dict)) #@UndefinedVariable

        if user_created_at is None and query_twitter:

            if self.access_token is not None:

                acess_token_key, access_token_secret = self.access_token

            else:

                acess_token_key, access_token_secret = get_oauth_token(self.token_filename)

                get_logger().info("get_user : TWITTER ERROR : " + repr(e)) #@UndefinedVariable

                get_logger().info("get_user : TWITTER ERROR : " + str(e)) #@UndefinedVariable

        user_obj = self.session.query(User).filter(User.id == user_dict["id"]).first()

        if user_obj is not None:

            if not do_merge:

                return ObjectBufferProxy(User, None, None, False, user_obj)

    def __get_or_create_object(self, klass, filter_by_kwargs, filter, creation_kwargs, must_flush, do_merge):

        obj_proxy = self.obj_buffer.get(klass, **filter_by_kwargs)

        if obj_proxy is None:

            query = self.session.query(klass)

            if filter is not None:

                query = query.filter(filter)

            else:

                query = query.filter_by(**filter_by_kwargs)

            obj_instance = query.first()

            if obj_instance is not None:

                if not do_merge:

                    obj_proxy = ObjectBufferProxy(klass, None, None, False, obj_instance)

                else:

                    obj_proxy = self.obj_buffer.add_object(klass, None, creation_kwargs, must_flush, obj_instance)

        if obj_proxy is None:

            obj_proxy = self.obj_buffer.add_object(klass, None, creation_kwargs, must_flush)

        return obj_proxy

        get_logger().debug("Process_entity : " + repr(ind) + " : " + repr(ind_type)) #@UndefinedVariable

        entity_type = self.__get_or_create_object(EntityType, {'label':ind_type}, None, {'label':ind_type}, True, False)

           "indice_start"   : ind["indices"][0],

           "indice_end"     : ind["indices"][1],

           "tweet_id"       : self.tweet.id,

           "entity_type_id" : entity_type.id,

           "source"         : adapt_json(ind)

        def process_medias():

            media_id = ind.get('id', None)

            if media_id is None:

                return None, None

            type_str = ind.get("type", "photo")

            media_type = self.__get_or_create_object(MediaType, {'label': type_str}, None, {'label':type_str}, True, False)

            media_ind = adapt_fields(ind, fields_adapter["entities"]["medias"])

            if "type" in media_ind:

                del(media_ind["type"])

            media_ind['type_id'] = media_type.id            

            media = self.__get_or_create_object(Media, {'id':media_id}, None, media_ind, True, False)

            entity_dict['media_id'] = media.id

            return EntityMedia, entity_dict

                return None, None

            ind['text'] = text

            hashtag = self.__get_or_create_object(Hashtag, {'text':text}, Hashtag.text.ilike(text), ind, True, False)

            user_mention = self.__get_user(ind, False, False)

            url = self.__get_or_create_object(Url, {'url':ind["url"]}, None, ind, True, False)

            'urls' : process_urls,

            'media': process_medias,

            }.get(ind_type, lambda: (Entity, entity_dict))()

        get_logger().debug("Process_entity entity_dict: " + repr(entity_dict)) #@UndefinedVariable

        user = self.__get_user(self.json_dict["user"], True)