diff --git a/KnowYourMemesParser.py b/KnowYourMemesParser.py
old mode 100755
new mode 100644
index 0dc19b2..650fa7e
--- a/KnowYourMemesParser.py
+++ b/KnowYourMemesParser.py
@@ -1,234 +1,230 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Tue Sep  6 17:40:12 2016
 
-@author: dmitrys
-"""
+# coding: utf-8
 
-###############################################################
-####       Meme parsing just for lulz and science  <3      ####
-###############################################################
+# authors: @DmitrySerg, @FUlyankin
+# repository: https://github.com/DmitrySerg/memology
 
+import requests      # отправка запросов
+import numpy as np   # матрицы, вектора и линал
+import pandas as pd  # таблички и операции с ними
+import time          # время
 
-import re
-from bs4 import BeautifulSoup
-import time
-import pandas as pd
-import numpy as np
-from urllib.request import Request, urlopen
-import getpass
-import sys
-sys.path.append('/Users/dmitrys/anaconda2/lib/python2.7/site-packages')
-username = getpass.getuser()
-
-#### Send me a letter
-import smtplib
-from email.mime.multipart import MIMEMultipart
-from email.mime.text import MIMEText
-#from email.mime.base import MIMEBase
-#from email import encoders
-import requests
-import sys
+from tqdm import tqdm                 # мониторинг прогресса
+from fake_useragent import UserAgent  # генерация правдоподобных юзер-агентов
+from bs4 import BeautifulSoup         # очень красивый суп для обработки html
 
+import argparse # чтение аргументов из коммандной строки
 
-#### GOING TO TOR
-import socks
+import socks   # подключение к тору
 import socket
-socks.set_default_proxy(socks.SOCKS5, "localhost", 9150)
-socket.socket = socks.socksocket
-#print(urlopen('http://icanhazip.com').read())
-
-
-from fake_useragent import UserAgent
-
-def generateUserAgent():
-    return UserAgent().chrome
-
-def html_stripper(text):
-    return re.sub('<[^<]+?>', '', str(text))
-
-
-number_of_pages = 369
-page = 1
-main_url = 'http://knowyourmeme.com/'
-columns = ['name', 'added', 'views', 'comments', 'status', 'year', 'tags', 'about', 'origin', 'spread']
-FINAL = pd.DataFrame(columns=columns)
-START = time.time()
-
-def getMemeUrls(page):
-    req = Request('http://knowyourmeme.com/memes/all/page/{}'.format(page), headers={'User-Agent': generateUserAgent()})
-    webpage = urlopen(req).read()
-    soup = BeautifulSoup(webpage, "lxml")
-    meme_urls = soup.findAll('a', attrs={'class':'photo'})
-    print('Getting all memes from page {}'.format(page))
-    return meme_urls
-
-
+import sys
 
-def getAllFromPage(meme_urls):
-    global FINAL
-    count = 0
-    start = time.time()
-    current_shape = FINAL.shape
-    for meme in meme_urls:
-        count += 1
 
+def getPageLinks(page_number):
+    """
+        Возвращает список ссылок на мемы, полученный с текущей страницы
         
-        to_append = {x:np.NaN for x in columns}
-        #time.sleep(1)
-        try:
-            meme_url = re.split('href="|" target="|"> <img|"', str(meme))[3]
-            meme_page = Request(main_url+meme_url, headers={'User-Agent': generateUserAgent()})
-            meme_page = urlopen(meme_page).read()
-            meme_page = BeautifulSoup(meme_page, 'lxml')
-        except:
-            continue
-        #### NAME & DATE
-        try:
-            raw = html_stripper(meme_page.find('section', attrs={'class':'info'})).split('\n')
-            for i in raw:
-                if i!='':
-                    name = i
-                    break
-            for j in range(len(raw)-1):
-                if raw[j] == 'Added':
-                    added = raw[j+1]
+        page_number: int/string
+            номер страницы для парсинга
             
-            to_append['name'] = name
-            to_append['added'] = added
-        except:
-            name = 'NULL'
-            continue
-        
-        #### VIEWS
-        try:
-            views = meme_page.find('dd', attrs = {'class':'views'})
-            views = re.split('title="| Views"', str(views))[1].replace(',', '')
-            to_append['views'] = views
-        except:
-            continue
-        
-        #### COMMENTS
-        try:
-            comments = meme_page.find('dd', attrs = {'class':'comments'})
-            comments = re.split('title="| Comments"', str(comments))[1]
-            to_append['comments'] = comments
-        except:
-            continue
+    """
+    # составляем ссылку на страницу поиска
+    page_link = 'http://knowyourmeme.com/memes/all/page/{}'.format(page_number)
+    
+    # запрашиваем данные по ней
+    response = requests.get(page_link, headers={'User-Agent': UserAgent().chrome})
+    
+    if not response.ok:
+        # если сервер нам отказал, вернем пустой лист для текущей страницы
+        return [] 
+    
+    # получаем содержимое страницы и переводим в суп
+    html = response.content
+    soup = BeautifulSoup(html,'html.parser')
+    
+    # наконец, ищем ссылки на мемы и очищаем их от ненужных тэгов
+    meme_links = soup.findAll(lambda tag: tag.name == 'a' and tag.get('class') == ['photo'])
+    meme_links = ['http://knowyourmeme.com' + link.attrs['href'] for link in meme_links]
+    
+    return meme_links
+
+def getStats(soup, stats):
+    """
+        Возвращает очищенное число просмотров/коментариев/...
         
-        #### PROPERTIES
-        try:
-            properties = meme_page.find('aside', attrs = {'class':'left'})
-            properties = html_stripper(properties).split('\n')
-            properties = [x for x in properties if x != '']
+        soup: объект bs4.BeautifulSoup 
+            суп текущей страницы
             
-            status = properties[1]
-            year = properties[3]
-            tags = properties[7]
+        stats: string
+            views/videos/photos/comments
             
-            to_append['status'] = status
-            to_append['year'] = year
-            to_append['tags'] = tags
-        except:
-            continue
-        #### ABOUT & ORIGINS & SPREAD
-        try:
-            raw = html_stripper(meme_page.find('section', attrs = {'class':'bodycopy'})).split('\n')
-            about, origin, spread = ('', '', '')
-            for i in range(len(raw)-1):
-                if raw[i] == 'About':
-                    about = raw[i+1]
-                elif raw[i] == 'Origin':
-                    origin = raw[i+1]
-                elif raw[i] == 'Spread':
-                    spread = raw[i+1]
-                    
-            to_append['about'] = about
-            to_append['origin'] = origin
-            to_append['spread'] = spread
-        except:
-            continue
-        #print('got {} meme!'.format(name))
-
-
-        sys.stdout.write("Meme number:   {}\r".format(count))
-        sys.stdout.flush()
+    """
+
+    obj = soup.find('dd', attrs={'class':stats})
+    obj = obj.find('a').text
+    obj = int(obj.replace(',', ''))
+    
+    return obj
+
+def getProperties(soup):
+    """
+        Возвращает список (tuple) с названием, статусом, типом, 
+        годом и местом происхождения и тэгами
         
+        soup: объект bs4.BeautifulSoup 
+            суп текущей страницы
+    
+    """
+    # название - идёт с самым большим заголовком h1, легко найти
+    meme_name = soup.find('section', attrs={'class':'info'}).find('h1').text.strip()
+    
+    # достаём все данные справа от картинки 
+    properties = soup.find('aside', attrs={'class':'left'})
+    
+    # статус идет первым - можно не уточнять класс
+    meme_status = properties.find("dd")
+    # oneliner, заменяющий try-except: если тэга нет в properties, вернётся объект NoneType,
+    # у которого аттрибут text отсутствует, и в этом случае он заменится на пустую строку
+    meme_status = "" if not meme_status else meme_status.text.strip()
+    
+    # тип мема - обладает уникальным классом
+    meme_type = properties.find('a', attrs={'class':'entry-type-link'})
+    meme_type = "" if not meme_type else meme_type.text 
+    
+    # год происхождения первоисточника можно найти после заголовка Year, 
+    # находим заголовок, определяем родителя и ищем следущего ребенка - наш раздел
+    meme_origin_year = properties.find(text='\nYear\n')
+    meme_origin_year = "" if not meme_origin_year else meme_origin_year.parent.find_next()
+    meme_origin_year = meme_origin_year.text.strip()
+    
+    # сам первоисточник
+    meme_origin_place = properties.find('dd', attrs={'class':'entry_origin_link'})
+    meme_origin_place = "" if not meme_origin_place else meme_origin_place.text.strip()
+    
+    # тэги, связанные с мемом
+    meme_tags = properties.find('dl', attrs={'id':'entry_tags'}).find('dd')
+    meme_tags = "" if not meme_tags else meme_tags.text.strip()
+    
+    return meme_name, meme_status, meme_type, meme_origin_year, meme_origin_place, meme_tags
+
+def getText(soup):
+    """
+        Возвращает текстовые описания мема
         
-
-        FINAL = FINAL.append(to_append, ignore_index=True)
-        
-    #### Now if we've been banned, send a letter and wait!
-    if FINAL.shape == current_shape:
-        print("Dayum son, something's wrong!")
-        raise ValueError
-        #unban = input('Gonna send`em? (y/n)')
-        unban = 'n'
-        if unban=="y":
-                   
-            IP = requests.request('GET', 'http://myip.dnsomatic.com').text
+        soup: объект bs4.BeautifulSoup 
+            суп текущей страницы
             
-            fromaddr = "MYMAIL"
-            msg = MIMEMultipart()
-             
-            msg['From'] = fromaddr
-            #bans@knowyourmeme.com
-            recipients = ['bans@knowyourmeme.com']
-            print('Now sending emails to {}'.format(", ".join(recipients)))
-            msg['To'] = ", ".join(recipients)
-            msg['Subject'] = "{} banned".format(IP)
-             
-        
-            # Fooling around with the message <3
-            import random
-            foo = ['Hi, please unban {}!', 
-                   'Sorry, working on a parsing project, please unban {}!', 
-                   'Sorry again, could you unban {}?', 
-                   'Hi, working on a parse project, please unban {}', 
-                   'Please, unban {}', 
-                   'Hi, could you, please, unban {} again?']
-            body = random.choice(foo).format(IP)
-            msg.attach(MIMEText(body, 'plain'))
-                     
-            server = smtplib.SMTP('smtp.gmail.com', 587)
-            server.starttls()
-            server.login(fromaddr, "PASSWORD")
-            text = msg.as_string()
-            server.sendmail(fromaddr, recipients, text)
-            server.quit()
-            print("Sent, now waiting for 30 mins")
-            time.sleep(1800)
-
-        else:
-            print("End of parsing")
-            raise ValueError
+    """
+    
+    # достаём все тексты под картинкой
+    body = soup.find('section', attrs={'class':'bodycopy'})
+    
+    # раздел about (если он есть), должен идти первым, берем его без уточнения класса
+    meme_about = body.find('p')
+    meme_about = "" if not meme_about else meme_about.text
+    
+    # раздел origin можно найти после заголовка Origin или History, 
+    # находим заголовок, определяем родителя и ищем следущего ребенка - наш раздел
+    meme_origin = body.find(text='Origin') or body.find(text='History')
+    meme_origin = "" if not meme_origin else meme_origin.parent.find_next().text
+    
+    # весь остальной текст (если он есть) можно запихнуть в одно текстовое поле
+    if body.text:
+        other_text = body.text.strip().split('\n')[4:]
+        other_text = " ".join(other_text).strip()
+    else:
+        other_text = ""
         
-    print('Total memes got {}'.format(count))
-    print('elapsed time: {} sec'.format(round(time.time()-start, 1)))
-    print('========')
-
-
-#for page in range(1, number_of_pages):
-#    print(re.split('href="|" target="|"> <img|"', str(getMemeUrls(page)[10]))[3])
-START_PAGE = int(input("enter the start page"))
-for page in range(START_PAGE, number_of_pages):
-    try:
-        #IP = urlopen(Request('http://icanhazip.com', headers={'User-Agent': generateUserAgent()})).read()
-        #print("Current IP is {}".format(IP))
-        getAllFromPage(getMemeUrls(page))
-        FINAL.to_csv('/Users/{}/Desktop/DataProjects/KnowYourMemes/{}'.format(username, 'Memes_final_second.csv'))
-        time.sleep(15)
-    except ValueError:
-        try:
-            print("Let's try again")
-            print("Current page is {}".format(page))
-            #print("Current IP is {}".format(IP))
-            time.sleep(600)
-            getAllFromPage(getMemeUrls(page))
-        except ValueError:
-            FINAL.to_csv('/Users/{}/Desktop/DataProjects/KnowYourMemes/{}'.format(username, 'Memes_{}.csv'.format(page)))
-            break
+    return meme_about, meme_origin, other_text
+
+def getMemeData(meme_page):
+    """
+        Запрашивает данные по странице, возвращает обработанный словарь с данными
         
-FINAL.to_csv('/Users/{}/Desktop/DataProjects/KnowYourMemes/{}'.format(username, 'Memes.csv'))
-print('Finished!')
-print('Total time: {}'.format((time.time() - START)/60))
\ No newline at end of file
+        meme_page: string
+            ссылка на страницу с мемом
+    
+    """
+    
+    # запрашиваем данные по ссылке
+    response = requests.get(meme_page, headers={'User-Agent': UserAgent().chrome})
+    
+    if not response.ok:
+        # если сервер нам отказал, вернем статус ошибки 
+        return response.status_code
+    
+    # получаем содержимое страницы и переводим в суп
+    html = response.content
+    soup = BeautifulSoup(html,'html.parser')
+
+    # используя ранее написанные функции парсим информацию
+    views = getStats(soup=soup, stats='views')
+    videos = getStats(soup=soup, stats='videos')
+    photos = getStats(soup=soup, stats='photos')
+    comments = getStats(soup=soup, stats='comments')
+
+    # дата
+    date = soup.find('abbr', attrs={'class':'timeago'}).attrs['title']
+
+    # имя, статус, и т.д.
+    meme_name, meme_status, meme_type, meme_origin_year, meme_origin_place, meme_tags =    getProperties(soup=soup)
+
+    # текстовые поля
+    meme_about, meme_origin, other_text = getText(soup=soup)
+
+    # составляем словарь, в котором будут хранится все полученные и обработанные данные
+    data_row = {"name":meme_name, "status":meme_status, 
+                "type":meme_type, "origin_year":meme_origin_year, 
+                "origin_place":meme_origin_place,
+                "date_added":date, "views":views, 
+                "videos":videos, "photos":photos, "comments":comments, "tags":meme_tags,
+                "about":meme_about, "origin":meme_origin, "other_text":other_text}
+
+    return data_row
+
+
+if __name__ == '__main__':
+    
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--PAGE_START', help='Choose starting page for parsing', required=True)
+    parser.add_argument('--PAGE_END', help='Choose final page for parsing', required=True)
+    args = parser.parse_args()
+
+    PAGE_START = int(args.PAGE_START)
+    PAGE_END = int(args.PAGE_END)
+
+
+    socks.set_default_proxy(socks.SOCKS5, "localhost", 9150)
+    socket.socket = socks.socksocket
+    final_df = pd.DataFrame(columns=['name', 'status', 'type', 'origin_year', 'origin_place',
+                                     'date_added', 'views', 'videos', 'photos', 'comments', 
+                                     'tags', 'about', 'origin', 'other_text'])
+
+
+    for page_number in range(PAGE_START, PAGE_END):
+        print("Page: {}".format(page_number))
+        # собрали хрефы с текущей страницы
+        for i in range(5):
+            meme_links = getPageLinks(page_number)  
+            if meme_links:
+                break
+            else:
+                #print("Banned on page")
+                time.sleep(20)
+                
+        for meme_link in meme_links:
+            # иногда с первого раза страничка не парсится
+            for i in range(5):
+                try:
+                    # пытаемся собрать по мему немного даты
+                    data_row = getMemeData(meme_link)           
+                    # и закидываем её в таблицу
+                    final_df = final_df.append(data_row, ignore_index=True)  
+                    # если всё получилось - выходим из внутреннего цикла
+                    break
+                except:
+                    # Иначе, пробуем еще несколько раз, пока не закончатся попытки
+                    #print("Banned on meme")
+                    time.sleep(20) 
+                    continue
+        final_df.to_csv('MEMES_{}_{}.csv'.format(PAGE_START, PAGE_END))
\ No newline at end of file