def pioneer_rate_mashups_o():
    sql_params = ( )
    rows = db_execute(pioneer_rate, sql_params)
    db_loop_pioneer_rate_to_database(rows, "pioneer_rate_apis_mashups_o")
    sql_params = ( )
    rows = db_execute(pioneer_rate_apis_mashups, sql_params)
    db_loop_pioneer_rate_apis_mashups(rows, "pioneer_rate_apis_mashups_o")
def api_popularity_rank_snapshot_o():
    sql_params = ( )
    rows = db_execute(api_popularity_rank, sql_params)
    #db_loop(rows, "api_popularity_rank_o")
    axx = analysis_plot.get_stacked_bar_axx(1, 1, 1)
    # get top apis list
    top_apis_id = list()
    top_apis_name = list()
    #print arrange_developer_sql_length_snapshot()
    developer_count = analysis_util.get_developer_length(arrange_developer_sql_length_snapshot(), 0)
    analysis_plot.set_stacked_bar_bottom(developer_count)
    index_count = 21
    index = range(index_count)
    color_util.create_rgbs(index_count)
    for i in index:
        row = rows.fetchone()
        api_id = row[1]
        api_name = row[2]
        top_apis_id.append(api_id)
        top_apis_name.append(api_name)
    print top_apis_name
    # other apis plot
    other_developer_index = []
    other_apis = []
    api_count_other_sql = api_deploy_other % str(tuple(top_apis_id))
    api_count_other_sql = arrange_developer_sql_snapshot("api_count", api_count_other_sql)
    print api_count_other_sql
    api_count_other_rows = db_execute(api_count_other_sql, ())
    for api_count_other_row in api_count_other_rows:
        other_developer_index.append(api_count_other_row[0])
        if api_count_other_row[1] == None:
            #print "*********"
            other_apis.append(0)
        else: 
            other_apis.append(api_count_other_row[1])
    print other_apis
    stack_color = 'w'
    print stack_color
    analysis_plot.developer_to_api_bar_plot(other_developer_index, other_apis, axx, stack_color, "Other APIs")
    # top api plot
    index = range(len(top_apis_id))
    for i in index:
        api_id = top_apis_id[i]
        api_name = top_apis_name[i]
        api_color = color_util.get_rgb(i)
        developer_index = []
        apis_is = []
        api_count_sql = arrange_developer_sql_snapshot("api_count", api_deploy_i)
        api_count_rows = db_execute(api_count_sql, (api_id, ))
        for api_row in api_count_rows:
            #print api[0], api[1]
            developer_index.append(api_row[0])
            if api_row[1] == None:
                apis_is.append(0)
            else: 
                apis_is.append(api_row[1])
        analysis_plot.developer_to_api_bar_plot(developer_index, apis_is, axx, api_color, api_name)
    analysis_plot.developer_to_api_bar_legend(axx, top_apis_name)        
def db_loop_api_usage(c, developer_number, cut_number, file_name):
    global analysis_path
    txt = open(analysis_path+file_name+".txt", "w")
    head = "index"
    for colum_name in c.description:
        head = head + ", \t"+str(colum_name[0])
    head = head + ", \tdeveloper_used"
    head = head + ", \tmashup_used"
    head = head + ", \tlow_end_mashup"
    head = head + ", \thigh_end_mashup"
    print head
    txt.write(head+"\n")
    i = 1
    for row in c:
        out = str(i)
        for r in row:
            out = out+"\t"+str(r)
        #print out
        api_id = row[0]
        #print api_id
        sql_params = (api_id, )
        rows = db_execute(api_developer_count, sql_params)
        developer_count = rows.fetchone()[0]
        sql_params = (api_id, )
        rows = db_execute(api_mashup_count, sql_params)
        mashup_count = rows.fetchone()[0]
        #print developer_count, mashup_count
        out = out+"\t"+str(developer_count)+"\t"+str(mashup_count)
        sql_params = (api_id, cut_number, )
        rows = db_execute(api_developer_count_condition_small, sql_params)
        api_developer_small = rows.fetchone()[0]
        sql_params = (api_id, cut_number, )
        rows = db_execute(api_developer_count_condition_large, sql_params)
        api_developer_large = rows.fetchone()[0]
        #print api_developer_small, api_developer_large
        out = out+"\t"+str(api_developer_small)+"\t"+str(api_developer_large)
        #print developer_condition_count
        print out
        txt.write(out+"\n")
        i = i+1
def get_developer_relationship(
        sql_params, 
        temp_sql, 
        temp_content_name, 
        file_name,
        plot_function = analysis_plot.developer_to_mashup_line_plot
        ):
    rows = db_execute(temp_sql, sql_params)
    db_loop(rows, file_name)
    sql = arrange_developer_sql(temp_content_name, temp_sql)
    rows = db_execute(sql, sql_params)
    developers = []
    contents = []
    for row in rows:
        #print row[0]
        developers.append(row[0])
        contents.append(row[1])
    #developers = range(len(mashups))
    #mashups = db_loop_for_array(rows, "developer_mashup_count_o", 2)
    #print developers
    #print
    #print mashups
    plot_function(developers, contents)
def api_db_loop(c, file_name):
    global analysis_path
    txt = open(analysis_path+file_name+".txt", "w")
    head = "index"
    for colum_name in c.description:
        head = head + ", \t"+str(colum_name[0])
    head = head + ", \tprotocols"
    head = head + ", \tdataformats"
    head = head + ", \t"
    head = head + ", \tmashup_full_url"
    head = head + ", \tmashup_if_free"
    head = head + ", \tmashup_other_comments"
    print head
    txt.write(head+"\n")
    i = 1
    for row in c:
        out = str(i)
        for r in row:
            out = out+"\t"+str(r)
        api_id = row[5]
        sql_params = (api_id, )
        rows_p = db_execute(api_protocol, sql_params)
        protocols = element_loop(rows_p)
        out = out+"\t"+protocols
        rows_d = db_execute(api_dataformats, sql_params)
        dataformats = element_loop(rows_d)
        out = out+"\t"+dataformats
        print out
        out = out+"\t"
        mashup_part_url = row[3]
        mashup_full_url = "http://www.programmableweb.com"+row[3]
        out = out+"\t"+mashup_full_url
        out = out+"\t"
        out = out+"\t"
        print out
        txt.write(out+"\n")
        i = i+1
def developer_index_tmp_table_prepare():
    global conn
    analysis_util.developer_index_tmp_table_init()
    sql_params = ( )
    #print developer_index_mashups
    i = 1
    rows = db_execute(developer_index_tmp, sql_params)
    author_id_rank = []
    for row in rows:
        author_id_rank.append(row[0])
    rows.close()
    for author_id in author_id_rank:
        #print author_id
        developer_index = i
        developer_id = author_id
        analysis_util.developer_index_tmp_table_update(developer_index, developer_id)
        i += 1
    analysis_util.developer_index_tmp_table_check()
def developer_api_mashup_count_o(developer_number):    
    sql_params = (developer_number, )
    rows = db_execute(developer_api_mashup_count, sql_params)
    analysis_util.db_loop(rows, "CACM_developer_api__mashup_count_"+str(developer_number)+"_o")
def api_usage_o(developer_number, cut_number):
    sql_params = (developer_number, )
    rows = db_execute(used_api, sql_params)
    db_loop_api_usage(rows, developer_number, cut_number, "CACM_api_usage_"+str(cut_number)+"_"+str(developer_number)+"_o")
def developer_mashup_o(developer_number):
    sql_params = (developer_number, )
    rows = db_execute(developer_mashup, sql_params)
    db_loop(rows, "CACM_developer_mashup_"+str(developer_number)+"_o")
def developer_mashup_api_category_dataformat_o(developer_number):
    sql_params = (developer_number, )
    rows = db_execute(developer_mashup_api_category_dataformat, sql_params)
    api_db_loop(rows, "CACM_developer_mashup_api_category_dataformat_"+str(developer_number)+"_o")
def apis_has_developer_count_o():
    sql_params = ( )
    rows = db_execute(apis_has_developer_count, sql_params)
    db_loop(rows, "apis_has_developer_count_o")
def developer_to_api_o():
    sql_params = ( )
    rows = db_execute(developer_to_api, sql_params)
    db_loop(rows, "developer_to_api_o")
def developer_api_time_o():
    sql_params = ( )
    rows = db_execute(develop_mashup, sql_params)
    db_loop_time(rows, "developer_api_time_o")
def pioneer_rate_o():
    sql_params = ( )
    rows = db_execute(pioneer_rate, sql_params)
    db_loop_pioneer_rate(rows, "pioneer_rate_o")
def api_developer_index_o():
    sql_params = ( )
    rows = db_execute(api_developer_index, sql_params)
    db_loop_api_developer_index(rows, "api_developer_index_o")