def remove_image(self, column, username):
with DBManager(self.file) as c:
c.execute('''
UPDATE users
SET {} = ?
WHERE username = ?'''.format(column),
('', username))
def __init__(self):
"""Init main class."""
doScrape = True
self.load_config()
self.init_config()
self.myDB = DBManager(self.config["BASIC"]["DBLocation"])
self.plugin_source = self.plugin_base.make_plugin_source(
searchpath=['./scrapers'])
for plugin_name in self.plugin_source.list_plugins():
plugin = self.plugin_source.load_plugin(plugin_name)
plugin.Scraper().setup(self)
doScrape = "-noscrape" not in sys.argv
doDl = "-nodl" not in sys.argv
if "-add" in sys.argv:
i = sys.argv.index("-add")
newShow = sys.argv[i + 1]
newLang = sys.argv[i + 2]
self.myDB.orderShow(newShow, newLang)
if doScrape:
self.scrape()
self.save_config()
self.myDB.matchEpisodes()
if doDl:
self.myDL = Downloader(self)
self.myDL.downloadQueue()
def __init__(self):
self.function_dict = {
self.choose_map_random: "choose_map_random",
1: "no"
}
self.db = DBManager()
self.map_manager = MapManager(self.db)
def store_image_fn(self, column, filename, username):
with DBManager(self.file) as c:
c.execute('''
UPDATE users
SET {} = ?
WHERE username = ?'''.format(column),
(filename, username))
def carregarDB(self):
db = DBManager(user=self.__cnfg__.get_db_user(),
senha=self.__cnfg__.get_db_passwd(),
end=self.__cnfg__.get_db_url(),
port=self.__cnfg__.get_db_port(),
database=self.__cnfg__.get_db_name())
return db
def login_user(self, username, password):
with DBManager(self.file) as c:
c.execute('''
select username from users
where username = ? and password = ?;
''',
(username, password))
return c.fetchone()
def register_user(self, username, password):
with DBManager(self.file) as c:
c.execute('''
INSERT INTO users (username, password) VALUES (?, ?)
''',
(username, password))
# Verify the user made it into the database
return self.user_exists(username)
def __init__(self):
super().__init__()
self.setupUi(self)
self.db_manager = DBManager('questions.db')
self.questions = []
self.load_questions()
self.bind_button_events()
self.selected_question = None
self.item_index = None
def send_notification(telegram_id, text):
# check if the user is a registered one
dbm = DBManager()
if dbm.exist_user_by_telegram_id(telegram_id):
logger.info(send_message(text=text, chat_id=telegram_id))
return HTTPResponse(status=200)
else:
return HTTPResponse(status=400)
def account_check(telegram_id):
# return if user exist + username + role
# e.g. (False, None, None) or (12345, 'Pepet', 'user')
dbm = DBManager()
resultset = dbm.get_user(telegram_id)
logger.info(resultset)
if len(resultset) == 0:
return False, None, None
else:
# its a shame there is no named tuple
return (True, resultset[1], resultset[3])
def __init__(self,
api_key,
path_db,
period_delay=10,
time_delay=5,
num_spots_max=20):
self.client = googlemaps.Client(api_key)
self.db = DBManager(path='./spots_tools.db')
self.period_delay = period_delay
self.time_delay = time_delay
self.num_spots_max = num_spots_max
def get_image_fn(self, column, username):
with DBManager(self.file) as c:
c.execute('''
SELECT {} FROM users
WHERE username = ?;
'''.format(column),
(username,))
try:
return c.fetchone()[0]
except TypeError:
return None
def user_exists(self, username):
with DBManager(self.file) as c:
c.execute('''
SELECT username FROM users
WHERE username = ?
''',
(username,))
if c.fetchone():
return c.fetchone()[0]
else:
return None
def __init__(self):
db_path = joinpath(globals.data_dir, globals.db_name)
#if not exists(db_path): create in db manager if not present
# log.error('db file not found')
# raise FBError
self._db = DBManager(db_path)
self._db.connect()
self._types = "(type = 46 OR type = 80 OR type = 128 OR type = 247 OR type = 308 OR type = 60)"
self._fql_limit = globals.max_fb_api_calls
def main():
db = DBManager()
for line in sys.stdin:
line = line.strip()
status = line.split('\t')
text = db.extract_text(status[0])
if text:
db.add_text(text)
print text, '\t', status[1]
if len(status)>=3:
db.since_id = status[2]
sys.stdout.flush()
return
def create_database(self):
with DBManager(self.file) as c:
c.execute('''
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY,
username TEXT UNIQUE,
password TEXT,
source_image TEXT,
target_image TEXT,
result_image TEXT
);
'''
)
def crawl(self, bot):
"""オリジナルユーザの発言をクロール"""
def remove_tab(text):
return text.replace('\t', ' ').replace('\n', ' ')
with DBManager(self._mecab, self._db_file) as db:
api = bot.api
arg = {}
arg['id'] = self._crawl_user
if db.since_id:
arg['since_id'] = db.since_id
new_statuses = []
statuses = tweepy.Cursor(api.user_timeline, **arg).items(3200)
for status in statuses:
#テキストログを作成
columns = [
remove_tab(status.text),
str(status.created_at),
str(status.id)
]
#リプライ先も取得
reply_to = None
if status.in_reply_to_status_id:
try:
reply_to = api.get_status(status.in_reply_to_status_id)
except:
pass
if reply_to:
columns.append(remove_tab(reply_to.text))
columns.append(str(reply_to.created_at))
columns.append(str(reply_to.id))
new_statuses.append('\t'.join(columns))
#DBへ登録
text = db.extract_text(status.text)
logger.debug('%s: %s' % (status.id, status.text))
if reply_to:
logger.debug('>%s: %s' % (reply_to.id, reply_to.text))
db.add_text(text)
db.since_id = str(max(int(db.since_id), int(status.id)))
with open('crawl.tsv', 'a') as f:
for line in reversed(new_statuses):
f.write(line.encode('utf-8') + '\n')
def __init__(self):
print _('TV-Maxe Channel Editor is starting...')
self.gui = gtk.Builder()
self.gui.add_from_file('ceditor.glade')
self.gui.connect_signals({
"quit": self.quit,
"deschide": self.deschide, #open
"openFile": self.openFile,
"openURL": self.openURL,
"hideOpenURL": self.hideOpenURL,
"goURL": self.goURL,
"saveList": self.saveList,
"showAddWindow": self.showAddWindow,
"hideAddWindow": self.hideAddWindow,
"addChannel": self.addChannel,
"editChannel": self.editChannel,
"hideChannelEditor": self.hideChannelEditor,
"saveChannel": self.saveChannel,
"deleteChannel": self.deleteChannel,
"uploadImage": self.uploadImage,
"salveaza": self.salveaza,
"addChannelURL": self.addChannelURL,
"addChannelEdit": self.addChannelEdit,
"removeChannelURL": self.removeChannelURL,
"addAudio": self.addAudio,
"addAudioEdit": self.addAudioEdit,
"removeAudio": self.removeAudio,
"saveNew": self.saveNew,
"saveInfo": self.saveNew2,
"hideInfo": self.hideInfo,
"on_entry2_changed": self.on_entry2_changed,
"hideLogoWin": self.hideLogoWin,
"selectIcon": self.selectIcon
})
self.imgur = Imgur()
self.imageFinder = imageFinder(self)
self.db = DBManager(':memory:')
self.db.build()
self.gui.get_object('cellrenderertext12').set_property(
'editable', True)
self.gui.get_object('cellrenderertext10').set_property(
'editable', True)
self.gui.get_object('cellrenderertext8').set_property('editable', True)
self.gui.get_object('cellrenderertext9').set_property('editable', True)
self.icons = {}
def main():
crawler = Crawler()
db = DBManager(DBType.SQLITE, 'github.db')
rate_limit = crawler.get_rate_limit()
logger.info("Rate Limit: %s Remaining: %s", rate_limit.limit,
rate_limit.remaining)
# repos = crawler.fetch_repositories_with_stars_in_range(10000, 100000)
# logger.info(repos)
repos = crawler.fetch_repositories_with_stars_in_range(100000, 200000)
logger.info(repos)
# Test the DB
for repo in repos:
db_repo = convert_api_repo_to_db(repo)
db.session.add(db_repo)
db.session.commit()
def __init__(self, api_key, size_matrix=10, time_delay=5):
self.client = googlemaps.Client(api_key)
self.db = DBManager(path='./spots_tools.db')
self.size_matrix = size_matrix
self.time_delay = time_delay
# extract id & location from SpotInfo DB
print('Extracting spots\' info from SpotInfo DB...', end=' ')
self.db.run_query('SELECT id, latitude, longitude FROM SpotInfo')
list_rows = self.db.fetch_all()
print('Success!')
# build the objects used for searching
self.num_spots = len(list_rows)
self.list_ids = [row['id'] for row in list_rows]
self.list_lats = [row['latitude'] for row in list_rows]
self.list_lngs = [row['longitude'] for row in list_rows]
# list of (index_min, index_max + 1) for each submatrix
self.list_ranges = [
(i, min(i + self.size_matrix, self.num_spots))
for i in xrange(0, self.num_spots, self.size_matrix)
]
def __init__(self, path):
config = ConfigManager.get_instance(path)
self.dbman = DBManager('delays',
'all',
conn_string=config.config['conn_string'])
pruebas de las librerías de Python y otros conceptos.
'''
import logging
import uvicorn
import os
from fastapi import Body, FastAPI
from fastapi.responses import JSONResponse
from fastapi.encoders import jsonable_encoder
from rich import inspect, print
from dbmanager import DBManager
from recommendator import Tweet, Recommendation, Recommendator
db = DBManager(
host=os.getenv('PB_DB_HOST', 'http://localhost'), # HOST
port=os.getenv('PB_DB_PORT', 2480), # PORT
user=os.getenv('PB_DB_USER', 'admin'), # USER
password=os.getenv('PB_DB_PASS', 'admin') # PASSWORD
)
app = FastAPI()
@app.post("/recommendation", response_class=JSONResponse)
async def getRecommendation(tweet: Tweet = Body(...,
embed=True)) -> Recommendation:
recommendator = Recommendator(db=db, tweet=tweet)
# getRecommendation puede devolver una recomendacion o un error
text, statusCode = recommendator.getRecommendation()
response = JSONResponse(content=jsonable_encoder(text),
status_code=statusCode)
return response
def BookParse(bookid, pages=None, exclude=None):
""" Takes id of book to parse. Id of book is one from DB,
and should correspond to filename as book12.pdf,
for id of the book in DB is 12. Also function accepts
optional argument "pages", it defines pages to parse, and
optional argument "exclude", to define pages to exclude.
Range format accepted: 1,2,3-8,15
"""
if pages is None:
pages = set()
if exclude is None:
exclude = set()
try:
bookfile = open("data/book" + str(bookid) + ".pdf", "rb")
except FileNotFoundError as e:
exception_msg(lg, e
, level="ERR"
, text="No such book (id=%s) in data dir."\
% str(bookid))
raise
mineparser = PDFParser(bookfile)
document = PDFDocument(mineparser)
if not document.is_extractable:
lg.error("PDF text extraction is not allowed.")
raise PDFTextExtractionNotAllowed
db = DBManager()
for pagenum, page in enumerate(PDFPage.create_pages(document)):
realnum = pagenum + 1
lg.info("Working on page %s (bookid=%s)", str(realnum), str(bookid))
if (len(pages) > 0 and realnum not in pages)\
or realnum in exclude:
lg.info("Page %s (bookid=%s) excluded.", str(realnum), str(bookid))
continue
# Insert page entry to db, no HTML
db.insert_page(bookid, realnum)
lg.info("Recognizing (pagenum=%s) of book (id=%s).", str(realnum),
str(bookid))
pagetype = recognize(bookid, page)
if pagetype == -1:
lg.warning("Can't recognize page (pagenum=%s) in book (id=%s).",
str(realnum), str(bookid))
lg.info("Page %s (bookid=%s) skipped.", str(realnum), str(bookid))
continue
lg.info("Parsing (pagenum=%s) of book (id=%s). Type (pagetype=%s).",
str(realnum), str(bookid), str(pagetype))
try:
data = parse(bookid, page, pagetype)
except Exception as e:
exception_msg(lg, e
, level="WARN"
, text="Errors while parsing."
" Skip (pagenum=%s) of book (id=%s)"\
% (str(realnum), str(bookid)))
continue
else:
lg.info(
"Inserting items to DB."
" (pagenum=%s) of book (id=%s). Type (pagetype=%s).",
str(realnum), str(bookid), str(pagetype))
try:
db.bulk_insert(bookid, data, pnum=realnum)
except Exception as e:
exception_msg(lg,
e,
level="ERR",
text="Errors during inserting data into DB."
" Maybe you should check the parser")
# Update page entry with parsed HTML
lg.info("Parsing to HTML (pagenum=%s) of book (id=%s).", str(realnum),
str(bookid))
try:
html = pdftohtml(page)
except Exception as e:
exception_msg(lg, e
, text="Cannot convert PDF to HTML."
" (pagenum=%s) of book (id=%s)"\
% (str(realnum), str(bookid)))
else:
lg.info(
"Inserting HTML to DB."
" (pagenum=%s) of book (id=%s). Type (pagetype=%s).",
str(realnum), str(bookid), str(pagetype))
db.insert_page(bookid, realnum, data=html)
lg.info(
"Done with page."
" (pagenum=%s) of book (id=%s). Type (pagetype=%s).", str(realnum),
str(bookid), str(pagetype))
#!venv/bin/python
from dbmanager import DBManager
from operator import itemgetter
import search
m = DBManager()
iquery = ['want', 'second', 'victory', 'guest', 'rica']
result = sorted(search.calcTF(iquery, m.relations, m.docs),
key=itemgetter('doc'))
for r in result:
print(r)
print("___________________\n\n\n")
result = sorted(search.calcAll(iquery, m.relations, m.docs, m.terms),
key=itemgetter('doc'))
for r in result:
print(r)
from argparse import ArgumentParser
from fact import FactType
from fact import Fact
from preprocessor import PreProcessor
from textcomparator import TextComparator
from dbmanager import DBManager
import config as cfg
import json
pre_processor = PreProcessor()
text_comp = TextComparator()
db_manager = DBManager()
def parse_args():
parser = ArgumentParser(description="Add a fact or fake fact")
parser.add_argument(
"fact",
choices=['truth', 'fake'],
help=
"\"fact\" if the given text is a true fact, \"fake\" if it is a fake fact"
)
parser.add_argument("-t",
"--text",
dest="text",
help="text to be added to fact database",
metavar="TEXT",
required=True)
parser.add_argument(
"-a",
"--append",
def get_text(self):
with DBManager(self._mecab, self._db_file) as db:
text = MarkovGenerator(db).get_text()
return text
def process_single_message(update):
# discard estrange messages
try:
telegram_id_from = int(update.get('message').get('from').get('id'))
except AttributeError:
return
# check user "credentials"
is_registered, username, role = account_check(telegram_id_from)
logging.info(f'{telegram_id_from} is_registered -> {is_registered}')
# kind of message to the bot; allowed: plain text and call_back
if 'callback_query' in update:
input_text = str(update.get('callback_query').get('data'))
elif 'message' in update:
input_text = str(update.get('message').get('text'))
else:
input_text = None
# Discard incorrect message formats
if input_text is None:
logger.info(
send_message(
'This bot only supports text messages, commands and callbacks',
telegram_id_from))
return
# TODO maybe not create an instace every time???
dbm = DBManager()
# User is not registered
if not is_registered:
# check if the message is a code!
if dbm.exist_code(input_text):
# pick info about the user and register it
field_username = update.get('message').get('from').get(
'username', '')
field_first_name = update.get('message').get('from').get(
'first_name', '')
field_last_name = update.get('message').get('from').get(
'last_name', '')
if username:
username = field_username
else:
username = f"{field_first_name} {field_last_name}"
dbm.add_user(telegram_id_from,
username,
role='user',
password=None)
dbm.delete_code(input_text)
logger.info(f'User {username} added correctly')
logger.info(
send_message('Registration successful ', telegram_id_from))
return
else:
send_message(
'To register yourself in the bot, copy a valid registration code',
telegram_id_from)
return
# Users only can get the conectivity info
if role == 'admin':
dbm = DBManager()
if input_text == 'gettemp':
logger.info(
send_message(f'Temperature -> {get_temperature()}ºC',
telegram_id_from))
elif input_text == 'listcodes':
codes = dbm.list_codes()
codes_msg = '\n'.join(codes) if codes else 'No codes yet!'
logging.info(send_message(codes_msg, chat_id=telegram_id_from))
# generate, add the code, send it to the user
elif input_text == 'addcode':
new_code = get_random_string(CODE_LENGTH)
dbm.add_code(new_code)
logger.info(
send_message(f'New code generated: {new_code}',
chat_id=telegram_id_from))
# only remove last code to not overcomplicate logic
# this is VERY suboptimal, but it works atm
elif input_text == 'removecode':
all_codes = dbm.list_codes()
if all_codes:
dbm.delete_code(all_codes[-1])
# remove last element
codes = all_codes[:-1]
codes_msg = '\n'.join(codes) if codes else 'No codes yet!'
logging.info(send_message(codes_msg, chat_id=telegram_id_from))
# add a default message on the admin side too
else:
info_message(telegram_id_from)
else:
info_message(telegram_id_from)
def __init__(self):
self.dbmanager = DBManager()
from cfgManager import Config
from dbmanager import DBManager
arqkey = open('../controle/chave.key', 'r')
chave = arqkey.readline()
arqkey.close()
cnfg = Config(chave, '../controle/yolzure.cfg')
del chave
db = DBManager(user=cnfg.get_db_user(),
senha=cnfg.get_db_passwd(),
end=cnfg.get_db_url(),
port=cnfg.get_db_port(),
database=cnfg.get_db_name())
db.abrir_con()
sql_lines = open('sql/sqlparametros.sql', 'r').read()
for sql in sql_lines.split(';'):
db.executar_inup(sql, None)
#Скрипт работает следующим образом: смотреть категории, количество товара и информацию по товару мы можем свободно.
#Для того, что бы попасть в админку ,где мы можем изменять наш товар - мы должны войти на страницу администратора (/admin)
# и там ввести логин - пароль администратора. (admin:123) если все верно - мы попадаем дальше на страницу с вводом
# товара и категорий.
#Проверка на права доступа отсуществляется следующим образом...
# Мы при вводе логин-пароль проверяемся в бд на право доступа на страницу, если такое право запсиано в бд для этого
# пользователя - нам разрешается вход и об этом идет запись к нам в кукисы. Дальшейшее попадание на страницу - через кукисы.
# Нет записи - доступ запрещен. Можно реализовать время валидности кукисов и смену ключа раз в сколько то времени.
# Ну это уже частности, реализован сам принцип.
from flask import Flask, request, url_for, render_template, redirect, make_response
from dbmanager import DBManager
from authorization import Authorization
app = Flask(__name__)
dbmanager = DBManager()
@app.route('/<cat_name>')
def category(cat_name):
if cat_name in dbmanager.get_category_name():
#Отсылаем запрос с категорией, которую выбрали, в БД. И в ответ получаем список товара, доступен-не доступен.
print(cat_name)
goods_list = dbmanager.get_category_info(cat_name)
print(goods_list)
return render_template('second_page.html',
category=cat_name,
goods=goods_list)
@app.route('/<cat_name>/<id>')
