Esempio n. 1
0
def process_xml_posted(xml):
    """
    Based on posted xml, construct the corresponding response
    :param xml: posted xml from WeChat server
    :return: respond body
    """

    wechatdata = WechatXml(xml)
    wechatdata.determine_media_type()
    # TODO: to extend to other types of media type
    if wechatdata.is_image:
        logging.info("\tReceived xml contains image")
        wechatdata.parse_image_xml()
        # store image content and info into storage and db
        wechatdb = Wechat_Database(wechatdata)
        wechatdb.store_media_info_to_db(xml)
        msg_info = wechatdata.xlm_content_dict
    elif wechatdata.is_msg:
        logging.info("\tReceived xml contains msg")
        wechatdata.parse_msg_xml()
        msg_info = wechatdata.xlm_content_dict
        if is_request_image_back(msg_info):
        # send image back. right now just a message
            logging.info("\tRecieved xml request: asking for photos")
            wechatdata.is_request = True
            downloader = RequestProcessor(msg_info)
            callback_msg_content = downloader.uploadAllPhotosOfUser()
            msg_info['content'] = callback_msg_content
    elif wechatdata.is_video:
        logging.info("\tReceived xml contains video")
        # store video content and info into storage and db
        wechatdata.parse_video_xml()
        wechatdb = Wechat_Database(wechatdata)
        wechatdb.store_media_info_to_db(xml)
        msg_info = wechatdata.xlm_content_dict
    else:
        logging.info("\tReceived other types of xml")
    # form response
    response = construct_response_msg(msg_info, wechatdata)
    return response
Esempio n. 2
0
def report_set_performance(set, days=7):
    '''
    Returns keywords performance report of given set for specified days count
    as a dictionary with keywords as keys and their perf values as the values
    of that dict.
    
    Some values may appear as None in case the value cannot be
    calculated yet.
    
    @param set: str
    @param days: int
    
    @return: dict
    '''
    adgroups = session.query(AdGroup).filter(AdGroup.set == set)
    
    if days < 1:
        raise ValueError('Days cannot be %d' % days)
    if adgroups.count() == 0:
        raise ValueError('Set "%s" not found' % set)
    
    campaign = adgroups.first().campaign
    processor = RequestProcessor(campaign.account.email, campaign.account.password)
    processor.sign_in()
    
    keywords = {}
    for adgroup in adgroups.all():
        keywords.update(processor.get_keywords_report(campaign.id, adgroup.id, days))
    
    processor.sign_out()
    
    return keywords
#-------------------------------------------------------------------------------
Esempio n. 3
0
def change_default_bid(set, bid):
    '''
    Changes default bid value of a set
    
    @param set: str
    @param bid: Decimal
    '''
    adgroups = session.query(AdGroup).filter(AdGroup.set == set)
    
    if adgroups.count() == 0:
        raise ValueError('Set "%s" not found' % set)
    else:
        campaign = adgroups.first().campaign
        processor = RequestProcessor(campaign.account.email, campaign.account.password)
        processor.sign_in()
        
        for adgroup in adgroups.all():
            processor.set_default_bid(campaign.id, adgroup.id, bid)
        
        processor.sign_out()
Esempio n. 4
0
def drop_set(set):
    '''
    Deletes the current set of keywords with related AdGroups.
    
    @param set: str
    '''
    adgroups = session.query(AdGroup).filter(AdGroup.set == set)
    
    if adgroups.count() == 0:
        raise ValueError('Set "%s" not found' % set)
    else:
        campaign = adgroups.first().campaign
        
        processor = RequestProcessor(campaign.account.email, campaign.account.password)
        processor.sign_in()
        
        for adgroup in adgroups.all():
            processor.delete_adgroup(campaign.id, adgroup.id)
            UsedNames.remove_entity(AdGroup.__name__, adgroup.id)
            session.delete(adgroup)
        
        session.commit()
        processor.sign_out()
Esempio n. 5
0
def get_keywords(set):
    '''
    Returns list of Keyword instances from given set.
    
    @param set: str
    
    @return: list
    '''
    adgroups = session.query(AdGroup).filter(AdGroup.set == set)
    
    if adgroups.count() == 0:
        raise ValueError('Set "%s" not found' % set)
    else:
        campaign = adgroups.first().campaign
        processor = RequestProcessor(campaign.account.email, campaign.account.password)
        processor.sign_in()
        
        keywords = []
        for adgroup in adgroups.all():
            keywords += processor.get_keywords(campaign.id, adgroup.id)
        
        processor.sign_out()
    
    return keywords
Esempio n. 6
0
def modify_keywords(set, new_keywords):
    '''
    Resubmits the keywords list of a given set with a new one.
    
    List can contain both strings and Keyword instances
    
    @param set: str
    @param keywords: list
    ''' 
    adgroups = session.query(AdGroup).filter(AdGroup.set == set)
    
    if adgroups.count() == 0:
        raise ValueError('Set "%s" not found' % set)
    if len(new_keywords) == 0:
        raise ValueError('"new_keywords" should not be empty')
    
    campaign = adgroups.first().campaign
    processor = RequestProcessor(campaign.account.email, campaign.account.password)
    processor.sign_in()
    
    an_adgroup = adgroups.first()
    adgroups = adgroups.all()
    
    while True:
        adgroup = adgroups.pop(0)
        keywords_part = new_keywords[:settings.MAX_KEYWORDS_PER_ADGROUP]
        new_keywords = new_keywords[settings.MAX_KEYWORDS_PER_ADGROUP:]
        
        campaign_name = UsedNames.get_entity_name(Campaign.__name__, campaign.id)
        adgroup_name = UsedNames.get_entity_name(AdGroup.__name__, adgroup.id)
        processor.set_keywords(campaign.id, adgroup.id, preprocess_keywords(keywords_part, campaign_name, adgroup_name))
        
        if len(adgroups) == 0 or len(new_keywords) == 0:
            break
        
    if len(adgroups) > 0:
        for adgroup_to_remove in adgroups:
            processor.delete_adgroup(campaign.id, adgroup_to_remove.id)
            session.delete(adgroup_to_remove)
            
    while len(new_keywords) > 0:
        if not (len(campaign.adgroups) < settings.MAX_ADGROUPS_PER_CAMPAIGN):
            raise OverflowError('limits exceeded during modifying keywords')
        
        new_adgroup_name = AdGroup.find_unique_name(set, campaign)
        campaign_name = UsedNames.get_entity_name(Campaign.__name__, campaign.id)
        new_adgroup_id = processor.add_adgroup(
            campaign.id, new_adgroup_name, an_adgroup.display_url, preprocess_url(an_adgroup.default_url, campaign_name, new_adgroup_name), 
            an_adgroup.headline, an_adgroup.adline1, an_adgroup.adline2, 
            preprocess_keywords(new_keywords[:settings.MAX_KEYWORDS_PER_ADGROUP], plain=True), an_adgroup.default_bid
        )
        UsedNames.add_entity(AdGroup.__name__, new_adgroup_id, campaign.id, new_adgroup_name)
        processor.set_keywords(campaign.id, new_adgroup_id, preprocess_keywords(new_keywords[:settings.MAX_KEYWORDS_PER_ADGROUP], campaign_name, new_adgroup_name))
        
        adgroup = AdGroup(long(new_adgroup_id), campaign.id, set,
            an_adgroup.default_bid, an_adgroup.default_url, an_adgroup.display_url, 
            an_adgroup.headline, an_adgroup.adline1, an_adgroup.adline2)
        session.add(adgroup)
        
        new_keywords = new_keywords[settings.MAX_KEYWORDS_PER_ADGROUP:]
        
    session.commit()
    processor.sign_out()
Esempio n. 7
0
def create_set(set, display_url, default_bid, default_url, headline, adline1, adline2, keywords, account_email=None):
    '''
    Creates a new keywords set.
    
    The current strategy is to prefer filling up existing campaigns/accounts
    instead of creating new ones. 'keywords' should be a list of strings and/or
    Keyword instances.
    
    Optional account argument can be used to explictly specify which account
    should be used to store a new set. OverflowError will be raised in case
    there's not enough capacity there to store a new set.
    
    @param set: str
    @param display_url: str
    @param default_bid: decimal.Decimal
    @param default_url: str
    @param headline: str
    @param adline1: str
    @param adline2: str
    @param keywords: list
    @param account_email: Account
    
    @return: Account
    '''
    
    if session.query(AdGroup).filter(AdGroup.set == set).count() > 0:
        raise ValueError('Set "%s" already exists' % set)

    if account_email:
        account = session.query(Account).filter(Account.email == account_email).first()
        if not account:
            raise ValueError('Account "%s" not found' % account_email)
    
    processor = None
    
    # getting how many parts should be created
    parts_count = int(len(keywords)) / int(settings.MAX_KEYWORDS_PER_ADGROUP)
    if int(len(keywords)) % int(settings.MAX_KEYWORDS_PER_ADGROUP) != 0:
        parts_count += 1
    if account_email and (parts_count > get_account_capacity(account_email)[0]):
        raise OverflowError('Specified account is not capable enough to store a set')
    
    # looking for campaigns capable to store required number of parts
    campaigns = session.query(Campaign).outerjoin(AdGroup) \
        .group_by(Campaign) \
        .having(func.count('*') <= (settings.MAX_ADGROUPS_PER_CAMPAIGN - parts_count)) \
        .order_by(desc(func.count('*')))
    if account_email:
        campaigns = campaigns.having(Campaign.account_id == account.id)
    
    if campaigns.count() > 0:
        # campaign found
        campaign = campaigns.first()
    else:
        # creating a new campaign
        # looking for an account to use
        if not account_email:
            accounts = session.query(Account).outerjoin(Campaign) \
                .group_by(Account) \
                .having(func.count('*') < settings.MAX_CAMPAIGNS_PER_ACCOUNT) \
                .order_by(desc(func.count('*')))
                
            if accounts.count() > 0:
                account = accounts.first()
            else:
                raise OverflowError('limits exceeded during new set creation')
        
        processor = RequestProcessor(account.email, account.password)
        processor.sign_in()
        
        keywords_part = keywords[:settings.MAX_KEYWORDS_PER_ADGROUP]
        
        new_campaign_name = Campaign.find_unique_name(account)
        new_adgroup_name = AdGroup.find_unique_name(set)
        new_campaign_id, new_adgroup_id = processor.add_campaign(
            new_campaign_name, new_adgroup_name, display_url, preprocess_url(default_url, new_campaign_name, new_adgroup_name), headline, adline1, adline2, 
            preprocess_keywords(keywords_part, plain=True), default_bid
        )
        UsedNames.add_entity(Campaign.__name__, new_campaign_id, account.id, new_campaign_name)
        UsedNames.add_entity(AdGroup.__name__, new_adgroup_id, new_campaign_id, new_adgroup_name)
        processor.set_keywords(new_campaign_id, new_adgroup_id, preprocess_keywords(keywords_part, new_campaign_name, new_adgroup_name))
        
        campaign = Campaign(long(new_campaign_id), account.id)
        session.add(campaign)
        
        adgroup = AdGroup(long(new_adgroup_id), long(new_campaign_id), set,
            default_bid, default_url, display_url, headline, adline1, adline2)
        session.add(adgroup)
        
        keywords = keywords[settings.MAX_KEYWORDS_PER_ADGROUP:]
        
    # now we have a campaign to put the rest of set parts into
    if not processor:
        processor = RequestProcessor(campaign.account.email, campaign.account.password)
        processor.sign_in()

    # creating the rest of set parts
    while len(keywords) > 0:
        keywords_part = keywords[:settings.MAX_KEYWORDS_PER_ADGROUP]
        
        campaign_name = UsedNames.get_entity_name(Campaign.__name__, campaign.id)        
        new_adgroup_name = AdGroup.find_unique_name(set, campaign)
        new_adgroup_id = processor.add_adgroup(
            campaign.id, new_adgroup_name, display_url, preprocess_url(default_url, campaign_name, new_adgroup_name), headline, adline1, adline2, 
            preprocess_keywords(keywords_part, plain=True), default_bid
        )
        UsedNames.add_entity(AdGroup.__name__, new_adgroup_id, campaign.id, new_adgroup_name)
        processor.set_keywords(campaign.id, new_adgroup_id, preprocess_keywords(keywords_part, campaign_name, new_adgroup_name))
        
        adgroup = AdGroup(long(new_adgroup_id), campaign.id, set,
            default_bid, default_url, display_url, headline, adline1, adline2)
        session.add(adgroup)
        
        keywords = keywords[settings.MAX_KEYWORDS_PER_ADGROUP:]

    processor.sign_out()
    session.commit()
    
    return campaign.account
Esempio n. 8
0
def clone_account(email_source, email_dest):
    '''
    Clones an account identified by its email to another one.
    
    Destination account should be empty (or at least to be capable enough
    to store all source account data). Removes source account after cloning.
    
    @param email_source: str
    @param email_dest: str
    '''
    account_from = session.query(Account).filter(Account.email == email_source).one()
    account_to = session.query(Account).filter(Account.email == email_dest).one()
    
    processor_from = RequestProcessor(account_from.email, account_from.password)
    processor_from.sign_in()
    
    processor_to = RequestProcessor(account_to.email, account_to.password)
    processor_to.sign_in()
    
    campaigns = session.query(Campaign).join(AdGroup).group_by(Campaign) \
        .filter(Campaign.account_id == account_from.id).all()
        
    for campaign in campaigns:
        adgroups = session.query(AdGroup).filter(AdGroup.campaign_id == campaign.id).all()
        first_adgroup = adgroups.pop(0)
        first_adgroup_keywords = processor_from.get_keywords(campaign.id, first_adgroup.id)
        
        new_campaign_name = Campaign.find_unique_name(account_to)
        new_adgroup_name = AdGroup.find_unique_name(first_adgroup.set)
        new_campaign_id, new_adgroup_id = processor_to.add_campaign(
            new_campaign_name, new_adgroup_name,
            first_adgroup.display_url, preprocess_url(first_adgroup.default_url, new_campaign_name, new_adgroup_name), 
            first_adgroup.headline, first_adgroup.adline1, first_adgroup.adline2, 
            preprocess_keywords(first_adgroup_keywords, plain=True), first_adgroup.default_bid
        )
        UsedNames.add_entity(Campaign.__name__, new_campaign_id, account_to.id, new_campaign_name)
        UsedNames.add_entity(AdGroup.__name__, new_adgroup_id, new_campaign_id, new_adgroup_name)
        
        processor_to.set_keywords(new_campaign_id, new_adgroup_id, preprocess_keywords(first_adgroup_keywords, new_campaign_name, new_adgroup_name))
        
        session.add(Campaign(long(new_campaign_id), account_to.id))
        session.add(AdGroup(long(new_adgroup_id), long(new_campaign_id), first_adgroup.set, 
                first_adgroup.default_bid, first_adgroup.default_url, first_adgroup.display_url, 
                first_adgroup.headline, first_adgroup.adline1, first_adgroup.adline2))
        
        for adgroup in adgroups:
            adgroup_keywords = processor_from.get_keywords(campaign.id, adgroup.id)
            
            campaign_name = UsedNames.get_entity_name(Campaign.__name__, campaign.id)
            new_adgroup_name = AdGroup.find_unique_name(adgroup.set, campaign)
            new_adgroup_id = processor_to.add_adgroup(
                campaign.id, new_adgroup_name, adgroup.display_url, preprocess_url(adgroup.default_url, campaign_name, new_adgroup_name), 
                adgroup.headline, adgroup.adline1, adgroup.adline2, 
                preprocess_keywords(adgroup_keywords, plain=True), adgroup.default_bid
            )
            UsedNames.add_entity(AdGroup.__name__, new_adgroup_id, campaign.id, new_adgroup_name)
            processor_to.set_keywords(campaign.id, adgroup.id, preprocess_keywords(first_adgroup_keywords, campaign_name, new_adgroup_name))
            
            session.add(AdGroup(long(new_adgroup_id), campaign.id, adgroup.set,
                adgroup.default_bid, adgroup.default_url, adgroup.display_url, 
                adgroup.headline, adgroup.adline1, adgroup.adline2))
            
    session.commit()
    processor_from.sign_out()
    processor_to.sign_out()
    remove_account(email_source)
    return flask.jsonify(data)


@app.route("/segment_board", methods=["POST"])
def segment_board():
    data = {"success": False}

    # ensure an image was properly uploaded to our endpoint
    if flask.request.method == "POST":
        if flask.request.files.get("image"):
            # read the image in PIL format
            image = flask.request.files["image"].read()
            image = Image.open(io.BytesIO(image))

            if image:
                image = np.array(image)
                print(image.shape)
                request_processor.segment_chess_board(image)
                data["success"] = True

    return flask.jsonify(data)


# if this is the main thread of execution first load the model and
# then start the server
if __name__ == "__main__":
    request_processor = RequestProcessor()
    redis_provider = RedisProvider()
    app.run(debug=True, use_reloader=False)