from flask import Flask, render_template, request, url_for, session, redirect
import json
import pymongo
from pymongo import MongoClient
import bcrypt
from bson import json_util
app=Flask(__name__)
cluster = MongoClient("mongodb+srv://root:[email protected]/test?retryWrites=true&w=majority")
db = cluster["bday"]
collection = db["responses"]
@app.route("/")
def home():
return render_template('index.html')
@app.route("/thank", methods=["GET"])
def thank():
return render_template('thank.html')
@app.route('/register', methods=['POST', 'GET'])
def register():
if request.method == 'POST':
collection.insert({'name' : request.form['name'],'meet' : request.form['meet'],'like' : request.form['like'],'memory' : request.form['memory'],'message' : request.form['message'] })
return redirect(url_for('thank'))
return render_template('index.html')
if __name__ == "__main__":
def __init__(self):
self._client = MongoClient("mongodb://localhost:27017")
print("connect to mongo, host=%s, port=%d success" %
("127.0.0.1", 27017))
import pymongo
from pymongo import MongoClient
import re
client = MongoClient()
db = client.FYP_Airtel_Storage
everything = db.FYP_Data
cursor = everything.find({}, {"MSISDN": 1})
one = 0
two = 0
three = 0
fourplus = 0
msisdn_array = []
for i in cursor:
#save each value in arrays
msisdn_array.append(i["MSISDN"])
total = msisdn_array.count()
print total
count = 0
for i in msisdn_array:
number = i["MSISDN"]
print number
countnum = everything.find({"MSISDN": number, "Trans": "1"}).count()
print countnum
if countnum == 1:
print i, "\t", "One"
one += 1
elif countnum == 2:
print i, "\tTwo"
two += 1
elif countnum == 3:
print i, "\tThree"
def __enter__(self):
self.client = MongoClient(host=self.host, port=self.port)
self.db = self.client[self.db_name]
self.collection = self.db[self.collection_name]
return self.collection
from nltk.stem import WordNetLemmatizer
from nltk.corpus import stopwords
from nltk.sentiment.vader import SentimentIntensityAnalyzer
from datetime import datetime, timedelta
from flask import Flask, request, jsonify, url_for
from pymongo import MongoClient
import redis
from flask_cors import CORS
import os
from dotenv import load_dotenv
import json
load_dotenv()
app = Flask(__name__)
mongo = os.getenv('MONGODB')
client = MongoClient(mongo)
db = client.news_db
news = db.news
CORS(app)
cache = redis.Redis(host='redis', port=6379, decode_responses=True)
def sentiment_analysis(description):
tokenized = word_tokenize(str(description))
tagged_tokens = nltk.pos_tag(tokenized)
lemmatizer = WordNetLemmatizer()
def lemmatize(pair):
word, tag = pair
try:
return lemmatizer.lemmatize(word, pos=tag[0].lower())
import gensim
from pymongo import MongoClient
import urllib
import nltk
from nltk.tokenize import RegexpTokenizer
tokenizer = RegexpTokenizer(r'\w+')
from nltk.sentiment.vader import SentimentIntensityAnalyzer
client = MongoClient(database)
db = client[exclient]
model = gensim.models.LdaModel.load("Example.model")
cursor = db.excollection.find({"text":{"$exists":True}}, {"text": 1})
tweets = []
tweet_list = []
#for each tweet in the file, add it to the list of tweets
for index in cursor:
tweet_list.append(index["text"])
#lowercase all words in tweets for cleanup
for t in tweet_list:
t_lower = t.lower()
tokens = tokenizer.tokenize(t_lower)
tweets.append(tokens)
def get(self):
client = MongoClient(DB_URI)
database = client[DB_NAME]
collection = database.nationalparks
return format_result(collection.find())
from pymongo import MongoClient import gridfs import pprint db = MongoClient().gridfs_example fs = gridfs.GridFS(db) a = fs.put(b"hello world")
from helpers import *
import pymongo # modules
from pymongo import MongoClient
import datetime
'''
instance of Flask
'''
app = Flask(__name__)
'''
Connecting flask with MONGODB
'''
client = MongoClient('mongodb+srv://new-user-31:[email protected]/flask-mongodb-atlas?retryWrites=true&w=majority&ssl=true&ssl_cert_reqs=CERT_NONE') # connect to engine.
db = client.Project2 # create database
mealplanner = db.mealPlanner
cook_database = db.cook
recipe_database = db.recipe_database
'''
Secret Key
Set's up secret key so flash messages can be displayed
'''
import configparser#import the key from secret file
config = configparser.ConfigParser()
config.read("credentials.ini")
app.secret_key = config["DEFAULT"]["KEY_FLASH"]
from pymongo import MongoClient
from datetime import datetime
import bson
import requests
import uuid
import config
import datatypes
connect(config.MONGO['connect'])
database_Name = config.DATABASE_CONNECTION['zeptoDB']
#connecting using pymongo
client = MongoClient(config.MONGO['client'])
db = client[database_Name]
class datarecords(MongoModel):
fileId = fields.CharField()
dataSetId = fields.CharField()
rowData = fields.ListField()
id = fields.IntegerField()
def getDataSet(fileName):
client = MongoClient(config.MONGO['client'])
db = client[database_Name]
dataset1 = db.datasets.find_one({'files.orgFileId': fileName})
return dataset1
def update_dataSetStatus(fileName, key, status):
client = MongoClient(config.MONGO['client'])
db = client[database_Name]
db.datasets.update_one({'files.orgFileId' : fileName}, {'$set' : { key : status } })
def fetch_db() -> Database:
client = MongoClient('192.168.6.208', 27017)
db = client['patent']
db.authenticate('kegger_patent', 'jingjieweiwu2016')
return db
import os
curPath = os.path.abspath(os.path.dirname(__file__))
rootPath = os.path.split(curPath)[0]
sys.path.append(rootPath)
import requests
from lxml import etree
import re
import time
import MySQLdb
import random
from urllib import parse
import remote.getIP as getIP
from pymongo import MongoClient
import json
mongoConn = MongoClient("mongodb://47.100.108.8:27017/")
mongoDb = mongoConn["parity"] #连接parity数据库，没有则自动创建
mongoSet = mongoDb["comments_tm"]
conn = MySQLdb.connect(host='127.0.0.1',
port=3306,
user='******',
passwd='',
charset='utf8',
db='proxy')
cursor = conn.cursor()
tryTime = 0
class GetIp():
def delete_ip(self, ip):
load_dotenv()
KAKAO_API_KEY = os.getenv('KAKAO_API_KEY')
HOST = os.getenv('HOST', '0.0.0.0')
USERNAME = os.getenv('USERNAME')
PASSWORD = os.getenv('PASSWORD')
# >>> client = MongoClient('example.com',
# … username='******',
# … password='******',
# … authSource='the_database',
# … authMechanism='SCRAM-SHA-1')
client = MongoClient(HOST,
27017,
username=USERNAME,
password=PASSWORD,
authMechanism='SCRAM-SHA-1')
db = client.session
app = Flask(__name__)
class MongoSession(CallbackDict, SessionMixin):
def __init__(self, initial=None, sid=None):
CallbackDict.__init__(self, initial)
self.sid = sid
self.modified = False
class MongoSessinoInterface(SessionInterface):
help="output file path",
required=True)
parser.add_argument('-n',
'--n_processes',
type=int,
default=20,
metavar="20",
help="amount of cpu for multiprocessing")
args = parser.parse_args()
limit = args.max_length
config = json.load(open(args.config, "rt", encoding="utf8"))
db_config = config['db_config']
client = MongoClient(**{
'host': db_config['host'],
'port': db_config['port']
})
db: Database = client[db_config['db']]
tweets_collections: Collection = db[db_config['collection']]
users_collection: Collection = db['users']
labeled_users = {}
for user in users_collection.find({"rating": {"$ne": None}}):
labeled_users[user['_id']] = user
print(bcolors.OKGREEN + "[+] Load users" + bcolors.ENDC)
print(bcolors.OKBLUE +
"[+] Total labeled users: {:,}".format(len(labeled_users)) +
bcolors.ENDC)
def setup_method(self, test_method):
client = MongoClient(kong.MONGO_URI())
cc = client.get_database(name="microsoftbotframework").get_collection("interest")
cc.remove({})
import nltk
from pymongo import MongoClient
from string import punctuation
from nltk.tokenize import word_tokenize
from nltk.stem.wordnet import WordNetLemmatizer
from nltk.corpus import stopwords
import re
# nltk.download('punkt')
# nltk.download('wordnet')
# nltk.download ('stopwords')
client = MongoClient("mongodb+srv://maac:[email protected]/test?retryWrites=true&w=majority")
db = client.assingment2
db_tweets = list(db.tweets.find())
# step 1: convert whole text to lowercase
tweets = []
for tweet in db_tweets:
tweets.append(tweet['body'].lower())
tokenized_tweets = []
for tweet in tweets:
# step 2: tokenize all the words
tokens = word_tokenize(tweet)
# step 3: remove all numeric tokens
re_num = re.compile(r'[0-9]')
tokens = [i for i in tokens if not re_num.match(i)]
# -*- coding: utf-8 -*-
"""
@author: Balaji
"""
from pymongo import MongoClient
from lxml import etree
import csv
client = MongoClient('localhost:27017')
db = client.database1
with open('world-cup-teams-text.csv', encoding='utf-8') as f:
next(f)
csv_f = csv.reader(f)
for row in csv_f:
db.team.insert_one({"Team_ID" : row[0] ,"Team_Name" : row[1],"Continent":row[2],"League":row[3],"Population":row[4]})
with open('players-text.csv', encoding='latin1') as f:
next(f)
csv_f1 = csv.reader(f)
for row in csv_f1:
db.player.insert_one({"Team_Name" : row[0] ,"Team_ID" : row[1],"PNo":row[2],
"Position":row[3],"PName":row[4],"Birth_Date":row[5],"Shirt_Name":row[6],"Club":row[7],"Height":row[8],"Weight":row[9]})
with open('world-cup-schedule-results-text.csv', encoding='utf-8') as f:
next(f)
csv_f2 = csv.reader(f)
sys.path.append(os.path.join(os.path.split(os.path.realpath(__file__))[0], '../../../util'))
sys.path.append(os.path.join(os.path.split(os.path.realpath(__file__))[0], '../../support'))
import config
import loghelper
import my_request
import util
import db
import extract
#logger
loghelper.init_logger("itjuzi_parser", stream=True)
logger = loghelper.get_logger("itjuzi_parser")
#mongo
(mongodb_host, mongodb_port) = config.get_mongodb_config()
mongo = MongoClient(mongodb_host, mongodb_port)
fromdb = mongo.crawler_v2
imgfs = gridfs.GridFS(mongo.gridfs)
#mysql
conn = None
# kafka
kafkaProducer = None
kafkaConsumer = None
#
SOURCE=13030
def initKafka():
global kafkaProducer
from flask import Flask, redirect, url_for, request
from logging.handlers import RotatingFileHandler
from pymongo import MongoClient
from bs4 import BeautifulSoup
from datetime import datetime
from random import random,randint
from apscheduler.scheduler import Scheduler
###### Setup timezone ##########################################################
utcmoment_unaware = datetime.utcnow()
utcmoment = utcmoment_unaware.replace(tzinfo=pytz.utc)
ltime = utcmoment.astimezone(pytz.timezone('Asia/Seoul'))
###### Connect to MongoDB ######################################################
client = MongoClient('mongodb://localhost/')
db = client.fishyDB
stats = db.counts
events = db.events
qoutes = db.qoutes
###### Set up our lovely fishyBOT for daily tweets #############################
CONSUMER_KEY = 'HmSpsXAzVRRWTBzlam5rU7dvD'
CONSUMER_SECRET = 'wsR9sIgSzgKuwEbLpUsnrjuytFOWWdnrkUAL9bgujNg5PRiUvv'
ACCESS_KEY = '822900504862683136-gmfpt0D7VvpKSda0CDpd3UYPObVXqGX'
ACCESS_SECRET = 'VZsgzkPuYgrLPZjcDC1hake9RgIJdycQ0llWf1NOy5avu'
auth = tweepy.OAuthHandler(CONSUMER_KEY,CONSUMER_SECRET)
auth.set_access_token(ACCESS_KEY, ACCESS_SECRET)
user = tweepy.API(auth)
app = Flask(__name__)
def __init__(self):
client = MongoClient('localhost', 27017)
self.db = client['online_judge_2017']
from flask import Flask, redirect, url_for, request, render_template, session
from flask_wtf import FlaskForm
from pymongo import MongoClient
from wtforms import Form, BooleanField, StringField, PasswordField, validators
from api import *
import acp_times
import arrow
import flask
import os
app = Flask(__name__)
client = MongoClient("db", 27017)
db = client.tododb
DEFAULT_TOP = 20
TOKEN_EXPIRATION = 60 * 10 # Seconds
app.config['SECRET_KEY'] = "Name this language: '2' + '2' = '22'"
@app.route('/')
def todo():
return render_template('calc.html')
@app.route('/login', methods=['POST', 'GET'])
def login():
form = LoginForm()
if form.validate_on_submit():
username, password = form.username.data, form.password.data
if True: #try:
data = db.cred_db.find({"username": username})
def main():
module = AnsibleModule(
argument_spec=dict(
login_user=dict(default=None),
login_password=dict(default=None, no_log=True),
login_host=dict(default='localhost'),
login_port=dict(default='27017'),
login_database=dict(default=None),
replica_set=dict(default=None),
database=dict(required=True, aliases=['db']),
name=dict(required=True, aliases=['user']),
password=dict(aliases=['pass'], no_log=True),
ssl=dict(default=False, type='bool'),
roles=dict(default=None, type='list'),
state=dict(default='present', choices=['absent', 'present']),
update_password=dict(default="always", choices=["always", "on_create"]),
ssl_cert_reqs=dict(default='CERT_REQUIRED', choices=['CERT_NONE', 'CERT_OPTIONAL', 'CERT_REQUIRED']),
),
supports_check_mode=True
)
if not pymongo_found:
module.fail_json(msg=missing_required_lib('pymongo'))
login_user = module.params['login_user']
login_password = module.params['login_password']
login_host = module.params['login_host']
login_port = module.params['login_port']
login_database = module.params['login_database']
replica_set = module.params['replica_set']
db_name = module.params['database']
user = module.params['name']
password = module.params['password']
ssl = module.params['ssl']
roles = module.params['roles'] or []
state = module.params['state']
update_password = module.params['update_password']
try:
connection_params = {
"host": login_host,
"port": int(login_port),
}
if replica_set:
connection_params["replicaset"] = replica_set
if ssl:
connection_params["ssl"] = ssl
connection_params["ssl_cert_reqs"] = getattr(ssl_lib, module.params['ssl_cert_reqs'])
client = MongoClient(**connection_params)
# NOTE: this check must be done ASAP.
# We doesn't need to be authenticated (this ability has lost in PyMongo 3.6)
if LooseVersion(PyMongoVersion) <= LooseVersion('3.5'):
check_compatibility(module, client)
if login_user is None and login_password is None:
mongocnf_creds = load_mongocnf()
if mongocnf_creds is not False:
login_user = mongocnf_creds['user']
login_password = mongocnf_creds['password']
elif login_password is None or login_user is None:
module.fail_json(msg='when supplying login arguments, both login_user and login_password must be provided')
if login_user is not None and login_password is not None:
client.admin.authenticate(login_user, login_password, source=login_database)
elif LooseVersion(PyMongoVersion) >= LooseVersion('3.0'):
if db_name != "admin":
module.fail_json(msg='The localhost login exception only allows the first admin account to be created')
# else: this has to be the first admin user added
except Exception as e:
module.fail_json(msg='unable to connect to database: %s' % to_native(e), exception=traceback.format_exc())
if state == 'present':
if password is None and update_password == 'always':
module.fail_json(msg='password parameter required when adding a user unless update_password is set to on_create')
try:
if update_password != 'always':
uinfo = user_find(client, user, db_name)
if uinfo:
password = None
if not check_if_roles_changed(uinfo, roles, db_name):
module.exit_json(changed=False, user=user)
if module.check_mode:
module.exit_json(changed=True, user=user)
user_add(module, client, db_name, user, password, roles)
except Exception as e:
module.fail_json(msg='Unable to add or update user: %s' % to_native(e), exception=traceback.format_exc())
finally:
try:
client.close()
except Exception:
pass
# Here we can check password change if mongo provide a query for that : https://jira.mongodb.org/browse/SERVER-22848
# newuinfo = user_find(client, user, db_name)
# if uinfo['role'] == newuinfo['role'] and CheckPasswordHere:
# module.exit_json(changed=False, user=user)
elif state == 'absent':
try:
user_remove(module, client, db_name, user)
except Exception as e:
module.fail_json(msg='Unable to remove user: %s' % to_native(e), exception=traceback.format_exc())
finally:
try:
client.close()
except Exception:
pass
module.exit_json(changed=True, user=user)
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.chrome.options import Options
from pymongo import MongoClient
import urllib.parse
import tweepy
import functions
import time
import asyncio
import secrets
username = urllib.parse.quote_plus(secrets.username)
password = urllib.parse.quote_plus(secrets.password)
client = MongoClient(secrets.mongo_url, secrets.mongo_port)
consumer_key = secrets.consumer_key
consumer_secret = secrets.consumer_secret
access_token = secrets.access_token
access_token_secret = secrets.access_token_secret
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)
api = tweepy.API(auth,
wait_on_rate_limit=True, wait_on_rate_limit_notify=True)
try:
api.verify_credentials()
print("Authentication OK")
import pymongo
from pymongo import MongoClient
import random
cluster = MongoClient("mongodb+srv://developer:[email protected]/test?retryWrites=true&w=majority")
MDB = cluster["MDB"]
def adduser(name, sex, age, country, username, password, bio):
error01 = "Username already in use"
collection = MDB['users']
username_list = [user["username"] for user in collection]
if username in username_list:
return error01
else:
user = {"name": name, "sex": sex, "age": age, "country": country, "username": username, "password": password, "bio": bio}
collection.insert_one(user)
def finduser(input):
collection = MDB['users']
for user in collection.find():
if user['username'] == input or user['name'] == input:
return user
def creategroup(group_name, description, requirements, username):
collection = MDB['groups']
id_list = [group["groupid"] for group in collection.find()]
rand = random.randrange(100000,999999,1)
while rand in id_list:
rand = random.randrange(100000,999999,1)
from nltk.sentiment.vader import SentimentIntensityAnalyzer
import thread_simulator
import pandas as pd
from pymongo import MongoClient
import praw
from global_sc import sc
import global_config
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
mc = MongoClient()
sid = SentimentIntensityAnalyzer()
def parseComment(reddit_comment):
ps = sid.polarity_scores(reddit_comment.body)
flair = reddit_comment.author_flair_css_class
flair = 'None' if flair is None else flair.split()[0].rstrip('1234567890')
fanbase_dict = global_config.FLAIRS[reddit_comment.subreddit.display_name]
fanbase = str(fanbase_dict[flair])
return (fanbase, [{
'fanbase': fanbase,
'created': int(reddit_comment.created),
'compound': ps['compound'],
'neg': ps['neg'],
'neu': ps['neu'],
'pos': ps['pos'],
'text': str(reddit_comment.body)
}])
import xmltodict, json
from pymongo import MongoClient
from pymongo.errors import DuplicateKeyError
f = open(
'/data/data03/sulantha/Downloads/ADNI/PET/xmls/ADNI_041_S_4143_AV45-Early_Coreg,_Avg,_Std_Img_and_Vox_Siz,_Uniform_Resolution_S199300_I389855.xml',
'r').read()
o = xmltodict.parse(f)
o['_id'] = '4143_S199300_I389855'
#print(json.dumps(o))
client = MongoClient()
client = MongoClient('localhost', 27017)
db = client.test_database
collection = db.test_collection
try:
post_id = collection.insert_one(o).inserted_id
print('Added')
except DuplicateKeyError:
print('Duplicate')
import pymongo
from pymongo import MongoClient
from add_id_name import get_box_options, get_pf_options, get_raw_options
from credentials import db_url
from PF_input import PF
import pandas as pd
from pprint import pprint
cluster = MongoClient(db_url)
db = cluster["Recepts"]
collection = db["Products"]
def get_pf_recept(current_id):
collection_pf = db['PF']
result = collection_pf.find_one({"firm_id" : current_id})
return result
class Oreder:
def __init__(self, contragent_id, order_id=None, contragent=None, order_date=None, order_end_date=None):
self.contragent_id = contragent_id
self.contragent = contragent
self.order_id = order_id
self.order_date = order_date
product_urls.add(item_url)
item = {}
item['url'] = item_url
item['name'] = product.find_element_by_xpath(".//h4").text
item['price'] = product.find_element_by_xpath(
".//div[contains(@class, 'c-pdp-price__current')]").text.replace('\xa0', '')
result_items.append(item)
#ссылка на кнопку
next_button = container.find_elements_by_class_name("next-btn")
if last_len == len(product_urls) or not len(next_button):
break
last_len = len(product_urls)
next_button[0].click()
time.sleep(1)
pprint(result_items)
driver.close()
# 3 СЛОЖИТЬ ВСЕ В БД
from pymongo import MongoClient
client = MongoClient('127.0.0.1', 27017)
db = client['mvideo_db']
mvideo_db = db.mvideo
for item in result_items:
mvideo_db.update_one({'link': item['url']}, {'$set': item}, upsert=True)
async def inser_to_db(self, response):
conn = MongoClient('mongodb://localhost:27017')
db = conn.movie
await db.movie.inser(response)
