def testMakeChannelFilename(self):
self.assertEqual(plugins.makeChannelFilename('dir', '#foo'),
conf.supybot.directories.data() + '/#foo/dir')
self.assertEqual(plugins.makeChannelFilename('dir', '#f/../oo'),
conf.supybot.directories.data() + '/#f..oo/dir')
self.assertEqual(plugins.makeChannelFilename('dir', '/./'),
conf.supybot.directories.data() + '/_/dir')
self.assertEqual(plugins.makeChannelFilename('dir', '/../'),
conf.supybot.directories.data() + '/__/dir')
def _getDb(self, channel):
#sqlite = plugins.importSqlite()
filename = plugins.makeChannelFilename(self.filename, channel)
def p(s1, s2):
return int(
ircutils.nickEqual(s1.encode('iso8859-1'),
s2.encode('iso8859-1')))
# norf 4-1-2010
#ALTER TABLE quotegrabs ADD votes INTEGER DEFAULT 0;
if filename in self.dbs:
self.dbs[filename].create_function('nickeq', 2, p)
return self.dbs[filename]
if os.path.exists(filename):
self.dbs[filename] = sqlite.connect(filename)
self.dbs[filename].create_function('nickeq', 2, p)
return self.dbs[filename]
db = sqlite.connect(filename)
self.dbs[filename] = db
self.dbs[filename].create_function('nickeq', 2, p)
cursor = db.cursor()
cursor.execute("""CREATE TABLE quotegrabs (
id INTEGER PRIMARY KEY,
nick TEXT,
hostmask TEXT,
added_by TEXT,
added_at TIMESTAMP,
quote TEXT,
vote INTEGER DEFAULT 0
);""")
db.commit()
return db
def _getDb(self, channel, debug=False):
if channel in self.dbs:
return self.dbs[channel]
try:
import sqlalchemy as sql
self.sql = sql
except ImportError:
raise callbacks.Error('You need to have SQLAlchemy installed to use this ' \
'plugin. Download it at <http://www.sqlalchemy.org/>')
filename = plugins.makeChannelFilename(self.filename, channel)
engine = sql.create_engine(self.engine + filename, echo=debug)
metadata = sql.MetaData()
firsts = sql.Table('firsts', metadata,
sql.Column('id', sql.Integer, primary_key=True),
sql.Column('first', sql.Text, unique=True),
sql.Column('count', sql.Integer, default=1),
)
lasts = sql.Table('lasts', metadata,
sql.Column('id', sql.Integer, primary_key=True),
sql.Column('last', sql.Text, unique=True),
sql.Column('count', sql.Integer, default=1),
)
pairs = sql.Table('pairs', metadata,
sql.Column('id', sql.Integer, primary_key=True),
sql.Column('first', sql.Text, default=sql.null),
sql.Column('second', sql.Text, default=sql.null),
sql.Column('follow', sql.Text, default=sql.null),
sql.Column('count', sql.Integer, default=1),
sql.UniqueConstraint('first', 'second', 'follow'),
)
metadata.create_all(engine)
self.dbs[channel] = (engine, firsts, lasts, pairs)
return self.dbs[channel]
def _handleUrl(self,irc,channel,nick,url):
# 1 lookup from the db
scname='%s_%s'%(irc.network,channel)
if not UrlReader.databases.has_key(scname):
# new db
dbpath=plugins.makeChannelFilename('%s.db'%scname ,'urldata')
UrlReader.databases[scname]=bsddb.btopen(dbpath,'c')
urldb = UrlReader.databases[scname]
if urldb.has_key(url):
poster,title=pickle.loads(urldb[url])
msg='%s has already posted it: %s'%(poster,title)
irc.reply(msg.encode('utf-8'))
else:
try:
title=self._getTitle(url)
if title != None:
urldb[url]=pickle.dumps([nick.decode('utf-8'),title])
urldb.sync()
irc.reply(title.encode('utf-8'))
except:
traceback.print_exc()
irc.reply('No Title')
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
db = sqlite3.connect(filename)
db.text_factory = str
self.dbs[filename] = db
return db
db = sqlite3.connect(filename)
db.text_factory = str
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE karma (
id INTEGER PRIMARY KEY,
name TEXT,
normalized TEXT UNIQUE ON CONFLICT IGNORE,
added INTEGER,
subtracted INTEGER
)""")
db.commit()
def p(s1, s2):
return int(ircutils.nickEqual(s1, s2))
db.create_function('nickeq', 2, p)
return db
def _getDb(self, channel):
try:
import sqlite3
except ImportError:
from pysqlite2 import dbapi2 as sqlite3 # for python2.4
if channel in self.dbs:
return self.dbs[channel]
filename = plugins.makeChannelFilename(self.filename, channel)
if os.path.exists(filename):
db = sqlite3.connect(filename, check_same_thread=False)
db.text_factory = str
self.dbs[channel] = db
return db
db = sqlite3.connect(filename, check_same_thread=False)
db.text_factory = str
self.dbs[channel] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE factoids (
key TEXT PRIMARY KEY,
created_by INTEGER,
created_at TIMESTAMP,
modified_by INTEGER,
modified_at TIMESTAMP,
locked_at TIMESTAMP,
locked_by INTEGER,
last_requested_by TEXT,
last_requested_at TIMESTAMP,
fact TEXT,
requested_count INTEGER
)""")
db.commit()
return db
def _getDb(self, channel):
try:
import sqlite
except ImportError:
raise callbacks.Error, 'You need to have PySQLite installed to ' \
'use Poll. Download it at ' \
'<http://pysqlite.org/>'
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
self.dbs[filename] = sqlite.connect(filename)
return self.dbs[filename]
db = sqlite.connect(filename)
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE polls (
id INTEGER PRIMARY KEY,
question TEXT UNIQUE ON CONFLICT IGNORE,
started_by INTEGER,
open INTEGER)""")
cursor.execute("""CREATE TABLE options (
id INTEGER,
poll_id INTEGER,
option TEXT,
UNIQUE (poll_id, id) ON CONFLICT IGNORE)""")
cursor.execute("""CREATE TABLE votes (
user_id INTEGER,
poll_id INTEGER,
option_id INTEGER,
UNIQUE (user_id, poll_id)
ON CONFLICT IGNORE)""")
db.commit()
return db
def _getDb(self, channel):
try:
import sqlite
except ImportError:
raise callbacks.Error, 'You need to have PySQLite installed to ' \
'use Poll. Download it at ' \
'<http://pysqlite.org/>'
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
self.dbs[filename] = sqlite.connect(filename)
return self.dbs[filename]
db = sqlite.connect(filename)
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE polls (
id INTEGER PRIMARY KEY,
question TEXT UNIQUE ON CONFLICT IGNORE,
started_by INTEGER,
open INTEGER)""")
cursor.execute("""CREATE TABLE options (
id INTEGER,
poll_id INTEGER,
option TEXT,
UNIQUE (poll_id, id) ON CONFLICT IGNORE)""")
cursor.execute("""CREATE TABLE votes (
user_id INTEGER,
poll_id INTEGER,
option_id INTEGER,
UNIQUE (user_id, poll_id)
ON CONFLICT IGNORE)""")
db.commit()
return db
def _getDb(self, channel):
import sqlite3
if channel in self.dbs:
return self.dbs[channel]
filename = plugins.makeChannelFilename(self.filename, channel)
if os.path.exists(filename):
db = sqlite3.connect(filename, check_same_thread=False)
if minisix.PY2:
db.text_factory = str
self.dbs[channel] = db
return db
db = sqlite3.connect(filename, check_same_thread=False)
if minisix.PY2:
db.text_factory = str
self.dbs[channel] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE factoids (
key TEXT PRIMARY KEY,
created_by INTEGER,
created_at TIMESTAMP,
modified_by INTEGER,
modified_at TIMESTAMP,
locked_at TIMESTAMP,
locked_by INTEGER,
last_requested_by TEXT,
last_requested_at TIMESTAMP,
fact TEXT,
requested_count INTEGER
)""")
db.commit()
return db
def _getDb(self, channel):
try:
import sqlite3
except ImportError:
raise callbacks.Error, \
'You need to have PySQLite installed to use this ' \
'plugin. Download it at ' \
'<http://code.google.com/p/pysqlite/>'
if channel in self.dbs:
return self.dbs[channel]
filename = plugins.makeChannelFilename(self.filename, channel)
if os.path.exists(filename):
self.dbs[channel] = sqlite3.connect(filename)
return self.dbs[channel]
db = sqlite3.connect(filename)
self.dbs[channel] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE factoids (
key TEXT PRIMARY KEY,
created_by INTEGER,
created_at TIMESTAMP,
modified_by INTEGER,
modified_at TIMESTAMP,
locked_at TIMESTAMP,
locked_by INTEGER,
last_requested_by TEXT,
last_requested_at TIMESTAMP,
fact TEXT,
requested_count INTEGER
)""")
db.commit()
return db
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
db = sqlite3.connect(filename, check_same_thread=False)
db.text_factory = str
self.dbs[filename] = db
return db
db = sqlite3.connect(filename, check_same_thread=False)
db.text_factory = str
self.dbs[filename] = db
cur = db.cursor()
cur.execute("""CREATE VIRTUAL TABLE quotes USING fts4(
text TEXT,
nick TEXT,
ts INTEGER
)""")
db.commit()
return db
def _getDb(self, channel):
sqlite = plugins.importSqlite()
filename = plugins.makeChannelFilename(self.filename, channel)
def p(s1, s2):
return int(ircutils.nickEqual(s1.encode('iso8859-1'),
s2.encode('iso8859-1')))
if filename in self.dbs:
self.dbs[filename].create_function('nickeq', 2, p)
return self.dbs[filename]
if os.path.exists(filename):
self.dbs[filename] = sqlite.connect(filename)
self.dbs[filename].create_function('nickeq', 2, p)
return self.dbs[filename]
db = sqlite.connect(filename)
self.dbs[filename] = db
self.dbs[filename].create_function('nickeq', 2, p)
cursor = db.cursor()
cursor.execute("""CREATE TABLE quotegrabs (
id INTEGER PRIMARY KEY,
nick TEXT,
hostmask TEXT,
added_by TEXT,
added_at TIMESTAMP,
quote TEXT
);""")
db.commit()
return db
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
db = sqlite3.connect(filename)
db.text_factory = str
self.dbs[filename] = db
return db
db = sqlite3.connect(filename)
db.text_factory = str
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute(
"""CREATE TABLE alias (
id INTEGER PRIMARY KEY,
name TEXT,
normalized TEXT,
aliases TEXT
)"""
)
db.commit()
def p(s1, s2):
return int(ircutils.nickEqual(s1, s2))
db.create_function("nickeq", 2, p)
return db
def _getDb(self, channel):
try:
import sqlite
except ImportError:
raise callbacks.Error, \
'You need to have PySQLite installed to use this ' \
'plugin. Download it at <http://pysqlite.org/>'
if channel in self.dbs:
return self.dbs[channel]
filename = plugins.makeChannelFilename(self.filename, channel)
if os.path.exists(filename):
self.dbs[channel] = sqlite.connect(filename)
return self.dbs[channel]
db = sqlite.connect(filename)
self.dbs[channel] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE factoids (
key TEXT PRIMARY KEY,
created_by INTEGER,
created_at TIMESTAMP,
modified_by INTEGER,
modified_at TIMESTAMP,
locked_at TIMESTAMP,
locked_by INTEGER,
last_requested_by TEXT,
last_requested_at TIMESTAMP,
fact TEXT,
requested_count INTEGER
)""")
db.commit()
return db
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
def p(s1, s2):
# text_factory seems to only apply as an output adapter,
# so doesn't apply to created functions; so we use str()
return ircutils.nickEqual(str(s1), str(s2))
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
db = sqlite3.connect(filename)
db.text_factory = str
db.create_function('nickeq', 2, p)
self.dbs[filename] = db
return db
db = sqlite3.connect(filename)
db.text_factory = str
db.create_function('nickeq', 2, p)
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE quotegrabs (
id INTEGER PRIMARY KEY,
nick BLOB,
hostmask TEXT,
added_by TEXT,
added_at TIMESTAMP,
quote TEXT
);""")
db.commit()
return db
def _getLastEntry(self, channel):
"""fetche the json data from either a file stored from the
last request (only 1 request per 15 minutes allowed) or
makes a new request and stores the result in a file as well
"""
filename = plugins.makeChannelFilename('bitcoin', channel)
# if file older than 15 minutes -> new query
if os.path.exists(filename) == True:
delta = datetime.timedelta(minutes=15)
statbuf = os.stat(filename)
now = datetime.datetime.now()
modtime = datetime.datetime.fromtimestamp(statbuf.st_mtime)
if (now - delta) > modtime:
data = self._fetchJsonData()
self._writeToFile(simplejson.dumps(data), filename)
log.info('new data')
return simplejson.dumps(data)
else:
data = self._readFromFile(filename)
log.info('old data')
return simplejson.dumps(data)
else:
data = self._fetchJsonData()
self._writeToFile(simplejson.dumps(data), filename)
log.info('create new file and new data')
return data
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
def p(s1, s2):
# text_factory seems to only apply as an output adapter,
# so doesn't apply to created functions; so we use str()
return ircutils.nickEqual(str(s1), str(s2))
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
db = sqlite3.connect(filename)
if minisix.PY2:
db.text_factory = str
db.create_function('nickeq', 2, p)
self.dbs[filename] = db
return db
db = sqlite3.connect(filename)
if minisix.PY2:
db.text_factory = str
db.create_function('nickeq', 2, p)
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE quotegrabs (
id INTEGER PRIMARY KEY,
nick BLOB,
hostmask TEXT,
added_by TEXT,
added_at TIMESTAMP,
quote TEXT
);""")
db.commit()
return db
def _handleUrl(self, irc, channel, nick, url):
# 1 lookup from the db
scname = '%s_%s' % (irc.network, channel)
if not UrlReader.databases.has_key(scname):
# new db
dbpath = plugins.makeChannelFilename('%s.db' % scname, 'urldata')
UrlReader.databases[scname] = bsddb.btopen(dbpath, 'c')
urldb = UrlReader.databases[scname]
if urldb.has_key(url):
poster, title = pickle.loads(urldb[url])
msg = '%s has already posted it: %s' % (poster, title)
irc.reply(msg.encode('utf-8'))
else:
try:
title = self._getTitle(url)
if title != None:
urldb[url] = pickle.dumps([nick.decode('utf-8'), title])
urldb.sync()
irc.reply(title.encode('utf-8'))
except:
traceback.print_exc()
irc.reply('No Title')
def _getDb(self, channel):
import sqlite3
if channel in self.dbs:
return self.dbs[channel]
filename = plugins.makeChannelFilename(self.filename, channel)
if os.path.exists(filename):
db = sqlite3.connect(filename, check_same_thread=False)
if sys.version_info[0] < 3:
db.text_factory = str
self.dbs[channel] = db
return db
db = sqlite3.connect(filename, check_same_thread=False)
if sys.version_info[0] < 3:
db.text_factory = str
self.dbs[channel] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE factoids (
key TEXT PRIMARY KEY,
created_by INTEGER,
created_at TIMESTAMP,
modified_by INTEGER,
modified_at TIMESTAMP,
locked_at TIMESTAMP,
locked_by INTEGER,
last_requested_by TEXT,
last_requested_at TIMESTAMP,
fact TEXT,
requested_count INTEGER
)""")
db.commit()
return db
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
db = sqlite3.connect(filename, check_same_thread=False)
db.text_factory = str
self.dbs[filename] = db
return db
db = sqlite3.connect(filename, check_same_thread=False)
db.text_factory = str
self.dbs[filename] = db
cur = db.cursor()
cur.execute("""CREATE VIRTUAL TABLE quotes USING fts4(
text TEXT,
nick TEXT,
ts INTEGER
)""")
db.commit()
return db
def _getDb(self, channel):
try:
import sqlite
except ImportError:
raise callbacks.Error, 'You need to have PySQLite installed to ' \
'use Karma. Download it at ' \
'<http://code.google.com/p/pysqlite/>'
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
self.dbs[filename] = sqlite.connect(filename)
return self.dbs[filename]
db = sqlite.connect(filename)
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE karma (
id INTEGER PRIMARY KEY,
name TEXT,
normalized TEXT UNIQUE ON CONFLICT IGNORE,
added INTEGER,
subtracted INTEGER
)""")
db.commit()
def p(s1, s2):
return int(ircutils.nickEqual(s1, s2))
db.create_function('nickeq', 2, p)
return db
def _getDb(self, channel):
try:
import sqlite
except ImportError:
raise callbacks.Error, 'You need to have PySQLite installed to ' \
'use QuoteGrabs. Download it at ' \
'<http://code.google.com/p/pysqlite/>'
filename = plugins.makeChannelFilename(self.filename, channel)
def p(s1, s2):
return int(ircutils.nickEqual(s1, s2))
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
self.dbs[filename] = sqlite.connect(filename,
converters={'bool': bool})
self.dbs[filename].create_function('nickeq', 2, p)
return self.dbs[filename]
db = sqlite.connect(filename, converters={'bool': bool})
self.dbs[filename] = db
self.dbs[filename].create_function('nickeq', 2, p)
cursor = db.cursor()
cursor.execute("""CREATE TABLE quotegrabs (
id INTEGER PRIMARY KEY,
nick TEXT,
hostmask TEXT,
added_by TEXT,
added_at TIMESTAMP,
quote TEXT
);""")
db.commit()
return db
def _getDb(self, channel, debug=False):
if channel in self.dbs:
return self.dbs[channel]
try:
import sqlalchemy as sql
self.sql = sql
except ImportError:
raise callbacks.Error('You need to have SQLAlchemy installed to use this ' \
'plugin. Download it at <http://www.sqlalchemy.org/>')
filename = plugins.makeChannelFilename(self.filename, channel)
engine = sql.create_engine(self.engine + filename, echo=debug)
metadata = sql.MetaData()
firsts = sql.Table('firsts', metadata,
sql.Column('id', sql.Integer, primary_key=True),
sql.Column('first', sql.Text, unique=True),
sql.Column('count', sql.Integer, default=1),
)
lasts = sql.Table('lasts', metadata,
sql.Column('id', sql.Integer, primary_key=True),
sql.Column('last', sql.Text, unique=True),
sql.Column('count', sql.Integer, default=1),
)
pairs = sql.Table('pairs', metadata,
sql.Column('id', sql.Integer, primary_key=True),
sql.Column('first', sql.Text, default=sql.null),
sql.Column('second', sql.Text, default=sql.null),
sql.Column('follow', sql.Text, default=sql.null),
sql.Column('count', sql.Integer, default=1),
sql.UniqueConstraint('first', 'second', 'follow'),
)
metadata.create_all(engine)
self.dbs[channel] = (engine, firsts, lasts, pairs)
return self.dbs[channel]
def _getDb(self, channel):
try:
import sqlite
except ImportError:
raise callbacks.Error, 'You need to have PySQLite installed to ' \
'use QuoteGrabs. Download it at ' \
'<http://pysqlite.org/>'
filename = plugins.makeChannelFilename(self.filename, channel)
def p(s1, s2):
return int(ircutils.nickEqual(s1, s2))
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
self.dbs[filename] = sqlite.connect(filename,
converters={'bool': bool})
self.dbs[filename].create_function('nickeq', 2, p)
return self.dbs[filename]
db = sqlite.connect(filename, converters={'bool': bool})
self.dbs[filename] = db
self.dbs[filename].create_function('nickeq', 2, p)
cursor = db.cursor()
cursor.execute("""CREATE TABLE quotegrabs (
id INTEGER PRIMARY KEY,
nick TEXT,
hostmask TEXT,
added_by TEXT,
added_at TIMESTAMP,
quote TEXT
);""")
db.commit()
return db
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
db = sqlite3.connect(filename, check_same_thread=False)
db.text_factory = str
self.dbs[filename] = db
return db
db = sqlite3.connect(filename, check_same_thread=False)
db.text_factory = str
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE karma (
id INTEGER PRIMARY KEY,
name TEXT,
normalized TEXT UNIQUE ON CONFLICT IGNORE,
added INTEGER,
subtracted INTEGER
)""")
db.commit()
def p(s1, s2):
return int(ircutils.nickEqual(s1, s2))
db.create_function('nickeq', 2, p)
return db
def _getDb(self, channel):
try:
import sqlite
except ImportError:
raise callbacks.Error, 'You need to have PySQLite installed to ' \
'use Karma. Download it at ' \
'<http://pysqlite.org/>'
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
self.dbs[filename] = sqlite.connect(filename)
return self.dbs[filename]
db = sqlite.connect(filename)
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE karma (
id INTEGER PRIMARY KEY,
name TEXT,
normalized TEXT UNIQUE ON CONFLICT IGNORE,
added INTEGER,
subtracted INTEGER
)""")
db.commit()
def p(s1, s2):
return int(ircutils.nickEqual(s1, s2))
db.create_function('nickeq', 2, p)
return db
def _getDb(self, channel):
if channel not in self.dbs:
filename = plugins.makeChannelFilename(self.filename, channel)
self.dbs[channel] = sqlite3.connect(filename)
c = self.dbs[channel].execute("PRAGMA user_version")
version = c.fetchone()[0]
self._upgradeDb(self.dbs[channel], version)
return self.dbs[channel]
def _getDb(self, channel):
if channel not in self.dbs:
filename = plugins.makeChannelFilename(self.filename, channel)
self.dbs[channel] = sqlite3.connect(filename)
c = self.dbs[channel].execute("PRAGMA user_version")
version = c.fetchone()[0]
self._upgradeDb(self.dbs[channel], version)
return self.dbs[channel]
def _getDb(self, channel):
import anydbm
if channel not in self.dbs:
filename = plugins.makeChannelFilename(self.filename, channel)
# To keep the code simpler for addPair, I decided not to make
# self.dbs[channel]['firsts'] and ['lasts']. Instead, we'll pad
# the words list being sent to addPair such that ['\n \n'] will be
# ['firsts'] and ['\n'] will be ['lasts'].
self.dbs[channel] = anydbm.open(filename, 'c')
return self.dbs[channel]
def _getDb(self, channel):
import anydbm
if channel not in self.dbs:
filename = plugins.makeChannelFilename(self.filename, channel)
# To keep the code simpler for addPair, I decided not to make
# self.dbs[channel]['firsts'] and ['lasts']. Instead, we'll pad
# the words list being sent to addPair such that ['\n \n'] will be
# ['firsts'] and ['\n'] will be ['lasts'].
self.dbs[channel] = anydbm.open(filename, 'c')
return self.dbs[channel]
def _getDb(self, channel):
if channel not in self.dbs:
filename = plugins.makeChannelFilename(self.filename, channel)
self.dbs[channel] = sqlite3.connect(filename)
self.dbs[channel].text_factory = str
c = self.dbs[channel].execute("PRAGMA user_version");
version = c.fetchone()[0]
self._upgradeDb(self.dbs[channel], version)
self.dbs[channel].create_function("REGEXP", 2, regexp)
return self.dbs[channel]
def _getDb(self, channel):
if channel not in self.dbs:
filename = plugins.makeChannelFilename(self.filename, channel)
# To keep the code simpler for addPair, I decided not to make
# self.dbs[channel]['firsts'] and ['lasts']. Instead, we'll pad
# the words list being sent to addPair such that ['\n \n'] will be
# ['firsts'] and ['\n'] will be ['lasts']. This also means isFirst
# and isLast aren't necessary, but they'll be left alone in case
# one of the other Db formats uses them or someone decides that I
# was wrong and changes my code.
self.dbs[channel] = anydbm.open(filename, 'c')
return self.dbs[channel]
def _getDb(self, channel):
if channel not in self.dbs:
filename = plugins.makeChannelFilename(self.filename, channel)
# To keep the code simpler for addPair, I decided not to make
# self.dbs[channel]['firsts'] and ['lasts']. Instead, we'll pad
# the words list being sent to addPair such that ['\n \n'] will be
# ['firsts'] and ['\n'] will be ['lasts']. This also means isFirst
# and isLast aren't necessary, but they'll be left alone in case
# one of the other Db formats uses them or someone decides that I
# was wrong and changes my code.
self.dbs[channel] = anydbm.open(filename, 'c')
return self.dbs[channel]
def get_db(self, channel):
if channel in self.engines:
engine = self.engines[channel]
else:
filename = plugins.makeChannelFilename(self.filename, channel)
exists = os.path.exists(filename)
engine = sqlalchemy.create_engine('sqlite:///' + filename)
if not exists:
Base.metadata.create_all(engine)
self.engines[channel] = engine
assert engine.execute("select 1").scalar() == 1
Session = sqlalchemy.orm.sessionmaker()
Session.configure(bind=engine)
return Session()
def get_db(self, channel):
if channel in self.engines:
engine = self.engines[channel]
else:
filename = plugins.makeChannelFilename(self.filename, channel)
exists = os.path.exists(filename)
engine = sqlalchemy.create_engine('sqlite:///' + filename)
if not exists:
Base.metadata.create_all(engine)
self.engines[channel] = engine
assert engine.execute("select 1").scalar() == 1
Session = sqlalchemy.orm.sessionmaker()
Session.configure(bind=engine)
return Session()
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
pass
elif os.path.exists(filename):
fd = file(filename)
try:
(Is, Are) = pickle.load(fd)
self.dbs[filename] = (Is, Are)
self.changes[filename] = 0
self.responses[filename] = 0
except cPickle.UnpicklingError, e:
fd.close()
raise dbi.InvalidDBError, str(e)
fd.close()
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
pass
elif os.path.exists(filename):
fd = file(filename)
try:
(Is, Are) = pickle.load(fd)
self.dbs[filename] = (Is, Are)
self.changes[filename] = 0
self.responses[filename] = 0
except cPickle.UnpicklingError, e:
fd.close()
raise dbi.InvalidDBError, str(e)
fd.close()
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
db = sqlite3.connect(filename, check_same_thread=False)
if sys.version_info[0] < 3:
db.text_factory = str
self.dbs[filename] = db
return db
db = sqlite3.connect(filename, check_same_thread=False)
if sys.version_info[0] < 3:
db.text_factory = str
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE pronouns (name TEXT PRIMARY KEY, pronoun TEXT)""")
db.commit()
def p(s1, s2):
return int(ircutils.nickEqual(s1, s2))
db.create_function('nickeq', 2, p)
return db
def _getDb(self, channel):
try:
import sqlite
except ImportError:
raise callbacks.Error, 'You need to have PySQLite installed to '\
'use this plugin. Download it at '\
'<http://pysqlite.org/>'
try:
filename = plugins.makeChannelFilename(self.filename, channel)
if filename not in self.changes:
self.changes[filename] = 0
if filename not in self.responses:
self.responses[filename] = 0
if filename in self.dbs:
return (self.dbs[filename], filename)
if os.path.exists(filename):
self.dbs[filename] = sqlite.connect(filename)
return (self.dbs[filename], filename)
db = sqlite.connect(filename)
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE isFacts (
key TEXT UNIQUE ON CONFLICT REPLACE,
value TEXT
);""")
cursor.execute("""CREATE TABLE areFacts (
key TEXT UNIQUE ON CONFLICT REPLACE,
value TEXT
);""")
db.commit()
for (k, v) in initialIs.iteritems():
self.setIs(channel, k, v)
for (k, v) in initialAre.iteritems():
self.setAre(channel, k, v)
self.changes[filename] = 0
self.responses[filename] = 0
return (db, filename)
except sqlite.DatabaseError, e:
raise dbi.InvalidDBError, str(e)
def get_db(self, channel):
if channel in self.engines:
engine = self.engines[channel]
else:
filename = plugins.makeChannelFilename(self.filename, channel)
exists = os.path.exists(filename)
engine = sqlite3.connect(filename, check_same_thread=False)
if not exists:
cursor = engine.cursor()
cursor.execute("""CREATE TABLE aliases (
id INTEGER NOT NULL,
name VARCHAR NOT NULL,
alias VARCHAR NOT NULL,
locked BOOLEAN NOT NULL,
locked_by VARCHAR,
locked_at DATETIME,
PRIMARY KEY (id),
UNIQUE (name))""")
engine.commit()
self.engines[channel] = engine
assert engine.execute("select 1").fetchone() == (1,)
return engine
def _getDb(self, channel):
try:
import sqlite
except ImportError:
raise callbacks.Error, 'You need to have PySQLite installed to '\
'use this plugin. Download it at '\
'<http://pysqlite.org/>'
try:
filename = plugins.makeChannelFilename(self.filename, channel)
if filename not in self.changes:
self.changes[filename] = 0
if filename not in self.responses:
self.responses[filename] = 0
if filename in self.dbs:
return (self.dbs[filename], filename)
if os.path.exists(filename):
self.dbs[filename] = sqlite.connect(filename)
return (self.dbs[filename], filename)
db = sqlite.connect(filename)
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE isFacts (
key TEXT UNIQUE ON CONFLICT REPLACE,
value TEXT
);""")
cursor.execute("""CREATE TABLE areFacts (
key TEXT UNIQUE ON CONFLICT REPLACE,
value TEXT
);""")
db.commit()
for (k, v) in initialIs.iteritems():
self.setIs(channel, k, v)
for (k, v) in initialAre.iteritems():
self.setAre(channel, k, v)
self.changes[filename] = 0
self.responses[filename] = 0
return (db, filename)
except sqlite.DatabaseError, e:
raise dbi.InvalidDBError, str(e)
def get_db(self, channel):
if channel in self.engines:
engine = self.engines[channel]
else:
filename = plugins.makeChannelFilename(self.filename, channel)
exists = os.path.exists(filename)
engine = sqlite3.connect(filename, check_same_thread=False)
if not exists:
cursor = engine.cursor()
cursor.execute("""CREATE TABLE aliases (
id INTEGER NOT NULL,
name VARCHAR NOT NULL,
alias VARCHAR NOT NULL,
locked BOOLEAN NOT NULL,
locked_by VARCHAR,
locked_at DATETIME,
PRIMARY KEY (id),
UNIQUE (name))""")
engine.commit()
self.engines[channel] = engine
assert engine.execute("select 1").fetchone() == (1,)
return engine
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
db = sqlite3.connect(filename, check_same_thread=False)
if minisix.PY2:
db.text_factory = str
self.dbs[filename] = db
return db
db = sqlite3.connect(filename, check_same_thread=False)
if minisix.PY2:
db.text_factory = str
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE lastfm (
id INTEGER PRIMARY KEY,
nick TEXT,
user TEXT
)""")
db.commit()
return db
def _getDb(self, channel):
filename = plugins.makeChannelFilename(self.filename, channel)
if filename in self.dbs:
return self.dbs[filename]
if os.path.exists(filename):
db = sqlite3.connect(filename)
db.text_factory = str
self.dbs[filename] = db
return db
db = sqlite3.connect(filename)
db.text_factory = str
self.dbs[filename] = db
cursor = db.cursor()
cursor.execute("""CREATE TABLE alias (
id INTEGER PRIMARY KEY,
name TEXT,
normalized TEXT,
aliases TEXT
)""")
db.commit()
def p(s1, s2):
return int(ircutils.nickEqual(s1, s2))
db.create_function('nickeq', 2, p)
return db
def makeFilename(self, channel):
return plugins.makeChannelFilename("QuoteGrabs.sqlite.db", channel)
def makeFilename(self, channel):
return plugins.makeChannelFilename("QuoteGrabs.sqlite.db", channel)
