keywords-val.py

#! /opt/local/bin/python2.7 -tt
# -*- coding: utf-8 -*-

import os
import re
import sys
import unicodedata
import json
import gzip
from datetime import datetime, timedelta 
import time



'Cloud Computing', 
'novateur', 
'nouvelle manière concevoir l informatique', 
'enjeux économiques', 
'marché gigantesque', 
'cent milliards de dollars', 
'géants de l informatique', 
'accès via internet', 
'simple interface web', 
'ressources infinies', 
'calcul',
'stockage', 
'réseaux',
'services à la demande',
'l échelle d un data center',
'la fiabilité d un data center',
'grandes entreprises',
'utilisateurs, ils payent',
'choses compliquées', 
'complexité disparait', 
'l informatique dématérialisée',
'The Network is the Computer',
'réseau est l ordinateur',
'serveurs qui ont une puissance',
'tas de fonctions',

'différents types de Cloud', 
'services de base',
'courrier électronique', 
'agenda', 
'manipulation de documents', 
'travail collaboratif',
'entreprises', 
'propre centre de données', 
'(leur) informatique', 
'(leurs) informaticiens', 
'faciliter (leur) fonctionnement', 
'particuliers', 
'grandes entreprises',
'moyennes entreprises',
'cible marché',
'donne accès',
'PMEs',
'moyens', 
'ressources', 
'n étaient accessibles jusqu à maintenant',
'supporter les besoins',
'Cloud d infrastructure','
'IaaS, Infrastructure as a Service',
'fourniture des ressources informatiques',
'calcul',
'réseau',
'stockage', 
'logiciel',
'Software as a Service',
'l application',
'accessible via le Cloud',
'ASP, Application Service Provider',
'fournisseur qui était accessible',
'l application d un fournisseur',
'applications développées par le client lui-même',
'Platform as a Service, PaaS',
'une plateforme de calcul',
'outils de développement',
'APIs',
'développeurs de créer',
'développer des nouvelles applications',
'sur l infrastructure du Cloud',
'intégrer avec (des) applications existantes',
'Google Apps',
'Google Apps Engine',
'véritable plateforme de développement',


'réduction des coûts',
'déporter toute son infrastructure',
'chez le fournisseur',
'pas besoin de posséder l infrastructure informatique',
'payer que pour ce qu elle consomme',
'l avantage pour le client',
'avantage majeur pour le fournisseur',
'la gestion des ressources',
'grand nombre de clients',
'réduire au maximum son coût de possession',
'et son coût d opération',
'facilité d utilisation pour les utilisateurs',
'suffit d avoir une connexion internet',
'ordinateur classique',
'ordinateur mobile',
'téléphone mobile',
'services sophistiqués',
'n importe quel endroit',
'qualité de service',
'entreprises expérimentées',
'gérer l infrastructure informatique de leurs clients',
'l élasticité',
'facile pour les utilisateurs',
'façon directe',
'façon complètement transparente',
'gérer leurs pics de charge',
'application de paiement',
'un magasin',
'la veille de Noël',
'cette application va être probablement très surchargée',
'beaucoup de clients',
'machines virtuelles',
'machines réelles',
'c est géré par le fournisseur',
'façon relativement transparente', 
'd augmenter la puissance de calcul', 
'la puissance de stockage'


inconvénients font que si on prend les grandes entreprises, 
les applications d'entreprise ne sont pas nécessairement intéressantes 
deux grands types d'applications 
le transactionnel, 
les applications bancaires, 
les applications de réservations.
les applications décisionnelles 
grands volumes de données 
prise de décision.
cohérence des données, 
les temps de réponse, 
la protection des données
opérateur dans lequel on n'a pas tout à fait confiance 
enjeux du Cloud Computing 
l'interopérabilité. 
problèmes d'interopérabilité 
problème d'interopérabilité des réseaux sociaux.
reprendre vos données 
mettre dans un autre réseau 
formats ne sont pas compatibles.
vrai enjeu 
veut pas que les utilisateurs, les entreprises, deviennent otages du fournisseur.
besoin de standards.
facilement de mettre ou de récupérer des données 
pour les mettre dans un autre Cloud.
la confidentialité.
garantissant de confidentialité.
réseaux sociaux. 
Facebook est un Cloud 
guillemets publiques 
fournisseur ce qu'il veut.
volume de données. 
passer à l'échelle 
(les) techniques de gestion de données 
très grandes architectures.
Autonomic Computing 
prend ses décisions 
gestion des données, 
gestion des applications, 
sans aucune intervention humaine.
Green Computing, 
une informatique verte.
fonctions, 
gros Data Centers 
consommation d'énergie majeure.
un enjeu pour le moteur de recherche 
consommer beaucoup d'énergie.
on mutualise les ressources 
peut mieux gérer la consommation d'énergie.




programmer des applications pour le Cloud 
régler de nouveaux problèmes de recherche. 
une véritable communauté de recherche 
qui regroupe des gens qui viennent des communautés de recherche en systèmes distribués, 
systèmes d'exploitation, 
gestion de données, 
réseaux sociaux 
sociologues pour étudier.
travaux de recherche.
Boom pour programmer le Cloud 
programmer rapidement des nouvelles applications 
langages de programmation généralement sont très bas niveau.
langages de programmation déclaratifs 






kw1 = [ 'Cloud Computing', 'directeur de recherche', 'Inria', 'responsable', 'équipe', 'Montpellier']

kw2 = [ 'concept novateur', 'enjeu(x)? économique(s)?', 'marché', '(cent|100) (milliard|md)(s)? de dollars', 
        'interface web', 'ressource(s)? (virtuellement )?infini(es)?', 'calcul', 'stockage', 'réseau(x)?', 'data( )?center',
        'services', 'informatique dématérialisé(e)?', '(The)? Network (is )?(the )?Computer', 'réseau (est )?(l )?ordinateur',  
        'serveurs', 'puissance' ]

kw3 = [ 'catégorie', 'client', 'particulier', 'service', 'courrier(s)? électronique', 'agenda', 'document', 'travail collaboratif', 
        'entreprise', 'centre de donnée', 'petites( et)? moyennes', 'PME', 'moyens', 'ressources',
        'Cloud (d )?infrastructure', 'IaaS', 'Infrastructure as a Service', 'ASP', 'Application Service Provider', 'fournisseur',
        'Platform as a Service', 'PaaS', 'plat(e)?forme de calcul', 'API', 'Software as a Service', 'Google Apps Engine',
        'développement' ]

kw4 = [ 'avantage', 'réduction', 'coût', 'PME', 'infrastructure', 'fournisseur', 'payer', 'consommer', 'mutualis(ation|e)', 
        'gestion', 'ressource', 'réduire', 'possession', 'opération', 'faciliter', 'utilisation', 'connexion',
        'mobile', 'qualité', 'service', 'Cloud', 'élasticité', 'pic', 'charge', 'application', 'paiement', 'Noel', 
        'surcharge', 'puissance', 'calcul', 'stockage' ] 
 
kw5 = [ 'grande(s)? entreprise', 'système', 'information', 'transactionnel', 'bancaire', 'réservation', 'décisionnelle', 'cohérence( des)? donnée', 
        'temps', 'réponse', 'protection( des)? donnée', 'opérateur', 'confiance', 'enjeu(x)?', 'Cloud Computing', 'interopérabilité', 'Microsoft', 
        'IBM', 'Google', 'Amazon', 'réseau(x)? sociau(x)?', 'compatib(le|ilité)', 'otage', 'fournisseur', 'standard', 'mettre', 'récupérer', 
        'confidentialité', 'Facebook', 'cloud', 'volume', 'donnée', 'passer( à)? (l )?échelle', 'architecture', 'Autonomic Computing', 'Green Computing', 
        'informatique verte', 'consommer', 'énergie', 'mutualis(ation|e)', 'ressource' ]

kw6 = [ 'programm(ation|er)', 'application', 'Cloud', 'industrie', 'communauté', 'recherche', 'système(s)? distribué', 'système(s)? (d )?exploitation', 
        'gestion (de )?donnée', 'réseau(x)? sociau', 'sociologue', 'Boom', 'langage(s)? (de )?(programmation)? déclaratif', 'base(s)? (de )?donnée' ]

delays = {
	'001': 0,
	'002': 4,
	'003': 8,
	'004': 4,
	'005': 8,
	'006': 0,
	'007': 6,
	'008': 6,
	'009': 10,
	'010': 10,
	'012': 6,
	'013': 10,
	'014': 4,
	'016': 8,
	'017': 0,
	'018': 4,
	'019': 0,
	'020': 8,
	'021': 6,
	'025': 10
}


def load_text_file(filename):
	with open(filename, "r") as text_file:
	    text = text_file.read()
	return text

def load_pad_revisions(db_file, padid):
	with gzip.open(db_file, 'rb') as f:		
		revisions = []
		pattern_rev_metadata = re.compile('{"key":"pad:'+padid+':revs:([0-9]+)"')
		pattern_rev_data = re.compile('pad:'+padid)

		while True:
			try:
				line = f.next()
				match = pattern_rev_metadata.match(line)
				if match:
					rev = int(match.group(1)) #-> to int ?
					rev_partA = json.loads(line)
					rev_partB = json.loads(f.next())
					if not pattern_rev_data.match(rev_partB['key']):
						raise Exception('missing pad content for rev:%i' % (rev))
					if rev_partB['val']['head'] != rev:
						raise Exception( 'head (%i) does not match with current rev (%i)' % (rev_partB['val']['head'], rev))
					revision = {}			
					revision['rev'] = rev
					revision['timestamp'] = rev_partA['val']['meta']['timestamp']
					revision['datetime'] = datetime.fromtimestamp(int(revision['timestamp']) / 1000)
					revision['author'] = rev_partA['val']['meta']['author']
					revision['content'] = rev_partB['val']['atext']['text']

					revisions.append(revision)

			except StopIteration:
				break
		return revisions

def format_time(timestamp):
	return timestamp.strftime('%H:%M:%S')

def get_revision(revisions, revision_num):
	return [ rev for rev in revisions if rev['rev'] == revision_num ][0]

def get_revision_at_time(revisions, certain_time):
	return [ rev for rev in revisions if rev['datetime'] <= certain_time ][-1]


SPLIT_MARKERS = [ '1. Cloud computing - concept innovateur \(Utilisateur 1 \+ Utilisateur 2\)',
                  '2. Différents types de clouds et de clients \(Utilisateur 3 \+ Utilisateur 4\)',
                  '3. Les avantages de cloud \(Utilisateur 1 \+ Utilisateur 2\)',
                  '4. Les inconvénients de cloud \(Utilisateur 3 \+ Utilisateur 4\)',
                  '5. Sujets de recherche en cloud computing \(Utilisateur 1 \+ Utilisateur 2\)' ]

SPLIT_MARKERS = [ '1. Cloud computing - concept innovateur \(Utilisateur 1 \+ Utilisateur 2\)',
                  '2. Diff.rents types de clouds et de clients \(Utilisateur 3 \+ Utilisateur 4\)',
                  '3. Les avantages de cloud \(Utilisateur 1 \+ Utilisateur 2\)',
                  '4. Les inconv.nients de cloud \(Utilisateur 3 \+ Utilisateur 4\)',
                  '5. Sujets de recherche en cloud computing \(Utilisateur 1 \+ Utilisateur 2\)' ]

UNESCAPED_SPLIT_MARKERS = [ m.replace('\\','') for m in SPLIT_MARKERS ]

def remove_markers(some_text):
	for marker in UNESCAPED_SPLIT_MARKERS:
		#some_text = some_text.replace(marker, '')
		some_text = re.sub(marker, '', some_text)
		
	return some_text

def remove_accents(input_str):
	nkfd_form = unicodedata.normalize('NFKD', input_str)
	return u"".join([c for c in nkfd_form if not unicodedata.combining(c)])

def uniformize_and_clean(some_text):
	some_text = some_text.decode(TEXT_ENCODING)
	some_text = remove_markers(some_text)
	some_text = some_text.lower()

	# Remove accents (replaced with the corresponding non-accented character)
	some_text = remove_accents(some_text)

	# Separate most punctuation
	some_text = re.sub(r"([^\w\.\'\-\/,&])", r' \1 ', some_text)

	# Separate commas if they're followed by space.
	# (E.g., don't separate 2,500)
	some_text = re.sub(r"(,\s)", r' \1', some_text)

	# Separate single quotes if they're followed by a space.
	# some_text = re.sub(r"('\s)", r' \1', some_text)

	# Separate single quotes
	some_text = re.sub(r"(\w)'(\w)", r"\1 ' \2", some_text)

	# Separate 'x/x' into 'x / x'
	some_text = re.sub(r"(\w)/(\w)", r'\1 / \2', some_text)

	# Separate periods that come before newline or end of string.
	some_text = re.sub('\. *(\n|$)', ' . ', some_text)

	# Remove 'punctuations' signs
	some_text = re.sub('[\.\'\-\/,&>\*=\+\(\):;\"\'\[\]\?!$~\^\|]', '', some_text)
	
	return some_text


def get_uniformized_keywords(): 
	some_keywords = kw1 + kw2 + kw3 + kw4 + kw5 + kw6
	some_keywords = [remove_accents(kw.decode(TEXT_ENCODING)).lower() for kw in some_keywords]
	some_keywords = list(set(some_keywords))
	return some_keywords 



INPUT_DATA_PATH='./DATA-by-num/'
INPUT_DATA_JSON_FILE='./chat-slicing-data-notes.json'
TEXT_ENCODING="utf-8"

with open(INPUT_DATA_JSON_FILE, "r") as json_data_file:
	data = json.loads(json_data_file.read())

	print '; group, delay (in s.), matching_keywords, non_matching_keywords '
	for group in sorted(data.keys()):
	#for group in ['019']:
		for experiment in data[group].keys():
			if group == '014' and (experiment == "corrections" or experiment == "films"):
				num = '015'
			else:
				num = group
  
		revisions = load_pad_revisions(INPUT_DATA_PATH + num + '/dirty.db.gz', experiment + num)

		initial_doc_rev_num = data[group][experiment]["init-rev"]
		first_changes_rev_num = data[group][experiment]["first-change-rev"]
		end_of_audio_rev_num = data[group][experiment]["end-of-audio-rev"]

		initial_doc_rev = get_revision(revisions, initial_doc_rev_num)
		first_changes_rev = get_revision(revisions, first_changes_rev_num)
		end_of_audio_rev = get_revision(revisions, end_of_audio_rev_num)

		# We consider only one revision at 5 minutes after end-of-audio
		considered_revision = get_revision_at_time(revisions, end_of_audio_rev['datetime'] + timedelta(minutes=5))
		
		text = considered_revision['content'].encode(TEXT_ENCODING)
		text = uniformize_and_clean(text)
		
		# Check if there still exist some non-words characters
		non_word_characters = set(re.sub('[A-Za-z0-9\s]', '', text))
		if (len(non_word_characters) > 0):
			print 'WARNING: seems that there are still some unexpected non-in-a-word characters - ', non_word_characters

		text = re.sub('\s+', ' ', text)

		ok = 0
		pas_ok = 0

		keywords = get_uniformized_keywords()
		for kw in keywords:
			pattern = re.compile(kw)

			if (pattern.search(text)):
				ok = ok + 1
			else:
				pas_ok = pas_ok + 1
				#print '***', kw

		print ",".join(map(lambda x: str(x), [int(num), delays[num], ok, pas_ok]))