Friends info.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "__author__ = 'Roman'\n",
    "# -*- coding: UTF-8 -*-\n",
    "\n",
    "import datetime\n",
    "import urllib\n",
    "import time\n",
    "import json, sys, codecs\n",
    "\n",
    "%run '../../conn_settings.ipynb'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Logger(object):\n",
    "\n",
    "    def __init__(self):\n",
    "        self.terminal = sys.stdout\n",
    "        self.log = codecs.open(\"logfile.log\", \"w+\", 'utf-8-sig')\n",
    "\n",
    "    def write(self, message):\n",
    "        self.terminal.write(message)\n",
    "        self.log.write(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_wall_posts(uid = default_id, offset = 0, count = 100):\n",
    "    # 100 posts max at a time\n",
    "    # we use offset as a measure of chunks of posts - how many to process\n",
    "    raw_data = urllib.urlopen(API + 'wall.get?owner_id=%s'\n",
    "                                    '&filter=owner'\n",
    "                                    '&offset=%s'\n",
    "                                    '&count=%s'\n",
    "                                    '&v=5.27'\n",
    "                                    '&access_token=%s' % (uid, offset, count, token))\n",
    "    data = json.load(raw_data)\n",
    "    time.sleep(sleep)\n",
    "\n",
    "    if offset != 0: # to get total number of posts in the first time (when offset = 0)\n",
    "        return data['response']['items']\n",
    "    else:\n",
    "        return data['response']['count'], data['response']['items'] # get total number of posts for further processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def unix_time_convert(unixtime):\n",
    "    #Converting post time from unix format to normal one\n",
    "    return datetime.datetime.fromtimestamp(unixtime).strftime('%Y-%m-%d')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_time_relevant_posts(posts, time_filter):\n",
    "    start_date = datetime.date.today() - datetime.timedelta(days=time_filter)\n",
    "\n",
    "    temp = []\n",
    "    for i in range(0, len(posts)):\n",
    "        if datetime.datetime.fromtimestamp(posts[i][\"date\"]).date() >= start_date:\n",
    "            temp.append(posts[i])\n",
    "\n",
    "    return len(temp), temp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#TODO: объединить с get_wall_posts\n",
    "def get_post_by_id(post_id, uid = default_id):\n",
    "    # get post data by post_id\n",
    "    raw_data = urllib.urlopen(API + 'wall.getById?posts=%s_%s'\n",
    "                                    '&v=5.27'\n",
    "                                    '&access_token=%s' % (uid, post_id, token))\n",
    "    data = json.load(raw_data)\n",
    "    time.sleep(sleep)\n",
    "    return data['response']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_one_post_data(post_tuple, top_id, top_num, flag, uid = default_id):\n",
    "    post_id, flag_count = post_tuple # decouple the tuple\n",
    "    post_data = get_post_by_id(post_id, uid)\n",
    "    if uid[0] == \"-\":\n",
    "        print ('%s from TOP-%s posts: http://vk.com/wall%s_%s (%s: %s)' % (top_id, top_num, uid, post_id, flag, flag_count))\n",
    "    else:\n",
    "        print ('%s from TOP-%s posts: http://vk.com/id%s?w=wall%s_%s (%s: %s)' % (top_id, top_num, uid, uid, post_id, flag, flag_count))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_top_posts(top_posts_data, flag, top_num, uid = default_id):\n",
    "    # print 'User: http://vk.com/id%s' % uid\n",
    "    print ('='*20, str(flag).upper(), '='*20)\n",
    "    for i in range(0, top_num):\n",
    "        if i == len(top_posts_data):\n",
    "            break\n",
    "        print_one_post_data(top_posts_data[i], i+1, top_num, flag, uid)\n",
    "    print ('='*20, \"END\", '='*20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def compute_top_posts(flag, posts, total_posts, uid = default_id):\n",
    "    top_num = 3\n",
    "    # get top-5 max posts according to flag\n",
    "    top_posts = get_max_post(uid, posts, total_posts, flag, top_num)\n",
    "    if top_posts != []:\n",
    "        post_id, flag_count = top_posts[0] # if the user ever posted anything we have a non-empty response list\n",
    "    else:\n",
    "        flag_count = 0 # otherwise just return 0 value\n",
    "\n",
    "    print_top_posts(top_posts, flag, top_num, uid)\n",
    "    return flag_count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_max_post(uid, posts_data, total_posts, flag, top_num):\n",
    "    temp = [] # temp list of posts with max number of flag - likes, comments or reposts\n",
    "    offset = 100 # number of posts to analyze\n",
    "    num_iter = (total_posts / offset) #\n",
    "\n",
    "    temp.extend( get_max_from_100(posts_data, flag) ) #put max from 1st chunk - 100 initial posts\n",
    "\n",
    "    for i in range(0, num_iter): # number of chunks of 100 posts to analyze\n",
    "        new_post_data = get_wall_posts(uid, offset)\n",
    "        temp.extend( get_max_from_100(new_post_data, flag) )\n",
    "        temp = sort_list_of_tuples(temp)[0:top_num]\n",
    "        # print str(offset + 100) + ' posts analyzed...'\n",
    "        offset += 100\n",
    "        print ('.',)\n",
    "\n",
    "    # print flag + ' are being analyzed.'\n",
    "\n",
    "    return sort_list_of_tuples(temp)[0:top_num]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_max_from_100(data_100posts, flag):\n",
    "    temp = []\n",
    "    num_iter = len(data_100posts)\n",
    "\n",
    "    for i in range(0, num_iter):\n",
    "        temp.append( ( data_100posts[i]['id'], data_100posts[i][flag]['count'] ) ) # (id, count of flag) tuple\n",
    "\n",
    "    return sort_list_of_tuples(temp)[0:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sort_list_of_tuples(list):\n",
    "\n",
    "    def getKey(item):\n",
    "        return item[1]\n",
    "\n",
    "    list.sort(key = getKey, reverse=True)\n",
    "\n",
    "    return list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def get_groups(uid = default_id, extended = 0):\n",
    "    raw_data = urllib.urlopen(API + 'groups.get?user_id=%s'\n",
    "                                    '&extended=%s'\n",
    "                                    '&v=5.27'\n",
    "                                    '&access_token=%s' % (uid, extended, token))\n",
    "    data = json.load(raw_data)\n",
    "    time.sleep(sleep)\n",
    "\n",
    "    return data['response']['items'] # get total number of posts for further processing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "\n",
    "    sys.stdout = Logger()\n",
    "\n",
    "    groups_list = get_groups(default_id)\n",
    "\n",
    "    # target_uid = raw_input(\"Enter VK user ID to analyse (or press ENTER to use default_id=%s): \" % default_id)\n",
    "    #\n",
    "    # if target_uid == '':\n",
    "    #     target_uid = default_id\n",
    "    #\n",
    "    # print\n",
    "\n",
    "    default_time_filter = 1 #days\n",
    "    time_filter = default_time_filter\n",
    "\n",
    "    # time_filter = raw_input(\"Enter time period to analyse (number of days) (or press ENTER to use default_time_filter=%s): \" % default_time_filter)\n",
    "    #\n",
    "    # if time_filter == '':\n",
    "    #     time_filter = default_time_filter\n",
    "    #\n",
    "    # print\n",
    "    count = 1\n",
    "    for target_uid in groups_list:\n",
    "\n",
    "        target_uid = str(-target_uid)\n",
    "        total_posts, posts = get_wall_posts(target_uid)\n",
    "\n",
    "    # time_filter = 1 #1 day\n",
    "    # time_filter = 7 #1 week\n",
    "    # time_filter = 30 #1 month\n",
    "\n",
    "        [num_posts, time_filtered_posts] = get_time_relevant_posts( posts, int(time_filter) )\n",
    "\n",
    "        flag1 = 'likes'\n",
    "        flag2 = 'comments'\n",
    "        flag3 = 'reposts'\n",
    "\n",
    "        print ('#'*40)\n",
    "        print( count, \"of\", len(groups_list), \": http://vk.com/public%s, %s posts\" % (target_uid, num_posts))\n",
    "        num_max_likes = compute_top_posts(flag1, time_filtered_posts, num_posts, target_uid)\n",
    "        num_max_comments = compute_top_posts(flag2, time_filtered_posts, num_posts, target_uid)\n",
    "        num_max_reposts = compute_top_posts(flag3, time_filtered_posts, num_posts, target_uid)\n",
    "        print ('#'*40)\n",
    "        count += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}