# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT


class Cache(object):

  def __init__(self):
    pass

  def display(self):
    """ For debugging only. """
    pass

  def get(self):
    """ Gets an entry from the cache or calls the factory function to produce one. """
    pass

class Connection(object):
  """ SQLite database connection object. """

  DataError = None
  DatabaseError = None
  Error = None
  IntegrityError = None
  InterfaceError = None
  InternalError = None
  NotSupportedError = None
  OperationalError = None
  ProgrammingError = None
  Warning = None

  def __init__(self):
    pass

  def close(self):
    """ Closes the connection. """
    pass

  def commit(self):
    """ Commit the current transaction. """
    pass

  def create_aggregate(self):
    """ Creates a new aggregate. Non-standard. """
    pass

  def create_collation(self):
    """ Creates a collation function. Non-standard. """
    pass

  def create_function(self):
    """ Creates a new function. Non-standard. """
    pass

  def cursor(self):
    """ Return a cursor for the connection. """
    pass

  def execute(self):
    """ Executes a SQL statement. Non-standard. """
    pass

  def executemany(self):
    """ Repeatedly executes a SQL statement. Non-standard. """
    pass

  def executescript(self):
    """ Executes a multiple SQL statements at once. Non-standard. """
    pass

  in_transaction = None

  def interrupt(self):
    """ Abort any pending database operation. Non-standard. """
    pass

  isolation_level = property(None, None, None,
                             )


  def iterdump(self):
    """ Returns iterator to the dump of the database in an SQL text format. Non-standard. """
    pass

  def rollback(self):
    """ Roll back the current transaction. """
    pass

  row_factory = None

  def set_authorizer(self):
    """ Sets authorizer callback. Non-standard. """
    pass

  def set_progress_handler(self):
    """ Sets progress handler callback. Non-standard. """
    pass

  def set_trace_callback(self, arg0):
    """ Sets a trace callback called for each SQL statement (passed as unicode). Non-standard. """
    pass

  text_factory = None
  total_changes = property(None, None, None,
                           )


class Cursor(object):
  """ SQLite database cursor class. """

  def __init__(self):
    pass

  arraysize = None

  def close(self):
    """ Closes the cursor. """
    pass

  connection = None
  description = None

  def execute(self):
    """ Executes a SQL statement. """
    pass

  def executemany(self):
    """ Repeatedly executes a SQL statement. """
    pass

  def executescript(self):
    """ Executes a multiple SQL statements at once. Non-standard. """
    pass

  def fetchall(self):
    """ Fetches all rows from the resultset. """
    pass

  def fetchmany(self):
    """ Fetches several rows from the resultset. """
    pass

  def fetchone(self):
    """ Fetches one row from the resultset. """
    pass

  lastrowid = None
  row_factory = None
  rowcount = None

  def setinputsizes(self):
    """ Required by DB-API. Does nothing in pysqlite. """
    pass

  def setoutputsize(self):
    """ Required by DB-API. Does nothing in pysqlite. """
    pass

class DataError(DatabaseError):

  pass

class DatabaseError(Error):

  pass

class Error(Exception):

  pass

class IntegrityError(DatabaseError):

  pass

class InterfaceError(Error):

  pass

class InternalError(DatabaseError):

  pass

class NotSupportedError(DatabaseError):

  pass

class OperationalError(DatabaseError):

  pass

class OptimizedUnicode(object):
  """ str(object='') -> str
  str(bytes_or_buffer[, encoding[, errors]]) -> str
  
  Create a new string object from the given object. If encoding or
  errors is specified, then the object must expose a data buffer
  that will be decoded using the given encoding and error handler.
  Otherwise, returns the result of object.__str__() (if defined)
  or repr(object).
  encoding defaults to sys.getdefaultencoding().
  errors defaults to 'strict'. """

  def capitalize(self):
    """ S.capitalize() -> str
    
    Return a capitalized version of S, i.e. make the first character
    have upper case and the rest lower case. """
    return ""

  def casefold(self):
    """ S.casefold() -> str
    
    Return a version of S suitable for caseless comparisons. """
    return ""

  def center(self, width, fillchar=None):
    """ S.center(width[, fillchar]) -> str
    
    Return S centered in a string of length width. Padding is
    done using the specified fill character (default is a space) """
    return ""

  def count(self, sub, start=None, end=None):
    """ S.count(sub[, start[, end]]) -> int
    
    Return the number of non-overlapping occurrences of substring sub in
    string S[start:end].  Optional arguments start and end are
    interpreted as in slice notation. """
    return 1

  def encode(self, encoding='utf-8', errors='strict'):
    """ S.encode(encoding='utf-8', errors='strict') -> bytes
    
    Encode S using the codec registered for encoding. Default encoding
    is 'utf-8'. errors may be given to set a different error
    handling scheme. Default is 'strict' meaning that encoding errors raise
    a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
    'xmlcharrefreplace' as well as any other name registered with
    codecs.register_error that can handle UnicodeEncodeErrors. """
    return None

  def endswith(self, suffix, start=None, end=None):
    """ S.endswith(suffix[, start[, end]]) -> bool
    
    Return True if S ends with the specified suffix, False otherwise.
    With optional start, test S beginning at that position.
    With optional end, stop comparing S at that position.
    suffix can also be a tuple of strings to try. """
    return None

  def expandtabs(self, tabsize=None):
    """ S.expandtabs([tabsize]) -> str
    
    Return a copy of S where all tab characters are expanded using spaces.
    If tabsize is not given, a tab size of 8 characters is assumed. """
    return ""

  def find(self, sub, start=None, end=None):
    """ S.find(sub[, start[, end]]) -> int
    
    Return the lowest index in S where substring sub is found,
    such that sub is contained within S[start:end].  Optional
    arguments start and end are interpreted as in slice notation.
    
    Return -1 on failure. """
    return 1

  def format(self, arg0, arg1):
    """ S.format(*args, **kwargs) -> str
    
    Return a formatted version of S, using substitutions from args and kwargs.
    The substitutions are identified by braces ('{' and '}'). """
    return ""

  def format_map(self, mapping):
    """ S.format_map(mapping) -> str
    
    Return a formatted version of S, using substitutions from mapping.
    The substitutions are identified by braces ('{' and '}'). """
    return ""

  def index(self, sub, start=None, end=None):
    """ S.index(sub[, start[, end]]) -> int
    
    Like S.find() but raise ValueError when the substring is not found. """
    return 1

  def isalnum(self):
    """ S.isalnum() -> bool
    
    Return True if all characters in S are alphanumeric
    and there is at least one character in S, False otherwise. """
    return None

  def isalpha(self):
    """ S.isalpha() -> bool
    
    Return True if all characters in S are alphabetic
    and there is at least one character in S, False otherwise. """
    return None

  def isdecimal(self):
    """ S.isdecimal() -> bool
    
    Return True if there are only decimal characters in S,
    False otherwise. """
    return None

  def isdigit(self):
    """ S.isdigit() -> bool
    
    Return True if all characters in S are digits
    and there is at least one character in S, False otherwise. """
    return None

  def isidentifier(self):
    """ S.isidentifier() -> bool
    
    Return True if S is a valid identifier according
    to the language definition.
    
    Use keyword.iskeyword() to test for reserved identifiers
    such as "def" and "class".
     """
    return None

  def islower(self):
    """ S.islower() -> bool
    
    Return True if all cased characters in S are lowercase and there is
    at least one cased character in S, False otherwise. """
    return None

  def isnumeric(self):
    """ S.isnumeric() -> bool
    
    Return True if there are only numeric characters in S,
    False otherwise. """
    return None

  def isprintable(self):
    """ S.isprintable() -> bool
    
    Return True if all characters in S are considered
    printable in repr() or S is empty, False otherwise. """
    return None

  def isspace(self):
    """ S.isspace() -> bool
    
    Return True if all characters in S are whitespace
    and there is at least one character in S, False otherwise. """
    return None

  def istitle(self):
    """ S.istitle() -> bool
    
    Return True if S is a titlecased string and there is at least one
    character in S, i.e. upper- and titlecase characters may only
    follow uncased characters and lowercase characters only cased ones.
    Return False otherwise. """
    return None

  def isupper(self):
    """ S.isupper() -> bool
    
    Return True if all cased characters in S are uppercase and there is
    at least one cased character in S, False otherwise. """
    return None

  def join(self, iterable):
    """ S.join(iterable) -> str
    
    Return a string which is the concatenation of the strings in the
    iterable.  The separator between elements is S. """
    return ""

  def ljust(self, width, fillchar=None):
    """ S.ljust(width[, fillchar]) -> str
    
    Return S left-justified in a Unicode string of length width. Padding is
    done using the specified fill character (default is a space). """
    return ""

  def lower(self):
    """ S.lower() -> str
    
    Return a copy of the string S converted to lowercase. """
    return ""

  def lstrip(self, chars=None):
    """ S.lstrip([chars]) -> str
    
    Return a copy of the string S with leading whitespace removed.
    If chars is given and not None, remove characters in chars instead. """
    return ""

  def maketrans(self, x, y=None, z=None):
    """ str.maketrans(x[, y[, z]]) -> dict (static method)
    
    Return a translation table usable for str.translate().
    If there is only one argument, it must be a dictionary mapping Unicode
    ordinals (integers) or characters to Unicode ordinals, strings or None.
    Character keys will be then converted to ordinals.
    If there are two arguments, they must be strings of equal length, and
    in the resulting dictionary, each character in x will be mapped to the
    character at the same position in y. If there is a third argument, it
    must be a string, whose characters will be mapped to None in the result. """
    return {}

  def partition(self, sep):
    """ S.partition(sep) -> (head, sep, tail)
    
    Search for the separator sep in S, and return the part before it,
    the separator itself, and the part after it.  If the separator is not
    found, return S and two empty strings. """
    return (None, None, None)

  def replace(self, old, new, count=None):
    """ S.replace(old, new[, count]) -> str
    
    Return a copy of S with all occurrences of substring
    old replaced by new.  If the optional argument count is
    given, only the first count occurrences are replaced. """
    return ""

  def rfind(self, sub, start=None, end=None):
    """ S.rfind(sub[, start[, end]]) -> int
    
    Return the highest index in S where substring sub is found,
    such that sub is contained within S[start:end].  Optional
    arguments start and end are interpreted as in slice notation.
    
    Return -1 on failure. """
    return 1

  def rindex(self, sub, start=None, end=None):
    """ S.rindex(sub[, start[, end]]) -> int
    
    Like S.rfind() but raise ValueError when the substring is not found. """
    return 1

  def rjust(self, width, fillchar=None):
    """ S.rjust(width[, fillchar]) -> str
    
    Return S right-justified in a string of length width. Padding is
    done using the specified fill character (default is a space). """
    return ""

  def rpartition(self, sep):
    """ S.rpartition(sep) -> (head, sep, tail)
    
    Search for the separator sep in S, starting at the end of S, and return
    the part before it, the separator itself, and the part after it.  If the
    separator is not found, return two empty strings and S. """
    return (None, None, None)

  def rsplit(self, sep=None, maxsplit=-1):
    """ S.rsplit(sep=None, maxsplit=-1) -> list of strings
    
    Return a list of the words in S, using sep as the
    delimiter string, starting at the end of the string and
    working to the front.  If maxsplit is given, at most maxsplit
    splits are done. If sep is not specified, any whitespace string
    is a separator. """
    return []

  def rstrip(self, chars=None):
    """ S.rstrip([chars]) -> str
    
    Return a copy of the string S with trailing whitespace removed.
    If chars is given and not None, remove characters in chars instead. """
    return ""

  def split(self, sep=None, maxsplit=-1):
    """ S.split(sep=None, maxsplit=-1) -> list of strings
    
    Return a list of the words in S, using sep as the
    delimiter string.  If maxsplit is given, at most maxsplit
    splits are done. If sep is not specified or is None, any
    whitespace string is a separator and empty strings are
    removed from the result. """
    return []

  def splitlines(self, keepends=None):
    """ S.splitlines([keepends]) -> list of strings
    
    Return a list of the lines in S, breaking at line boundaries.
    Line breaks are not included in the resulting list unless keepends
    is given and true. """
    return []

  def startswith(self, prefix, start=None, end=None):
    """ S.startswith(prefix[, start[, end]]) -> bool
    
    Return True if S starts with the specified prefix, False otherwise.
    With optional start, test S beginning at that position.
    With optional end, stop comparing S at that position.
    prefix can also be a tuple of strings to try. """
    return None

  def strip(self, chars=None):
    """ S.strip([chars]) -> str
    
    Return a copy of the string S with leading and trailing
    whitespace removed.
    If chars is given and not None, remove characters in chars instead. """
    return ""

  def swapcase(self):
    """ S.swapcase() -> str
    
    Return a copy of S with uppercase characters converted to lowercase
    and vice versa. """
    return ""

  def title(self):
    """ S.title() -> str
    
    Return a titlecased version of S, i.e. words start with title case
    characters, all remaining cased characters have lower case. """
    return ""

  def translate(self, table):
    """ S.translate(table) -> str
    
    Return a copy of the string S, where all characters have been mapped
    through the given translation table, which must be a mapping of
    Unicode ordinals to Unicode ordinals, strings, or None.
    Unmapped characters are left untouched. Characters mapped to None
    are deleted. """
    return ""

  def upper(self):
    """ S.upper() -> str
    
    Return a copy of S converted to uppercase. """
    return ""

  def zfill(self, width):
    """ S.zfill(width) -> str
    
    Pad a numeric string S with zeros on the left, to fill a field
    of the specified width. The string S is never truncated. """
    return ""

PARSE_COLNAMES = 2
PARSE_DECLTYPES = 1

class PrepareProtocol(object):

  def __init__(self):
    pass

class ProgrammingError(DatabaseError):

  pass

class Row(object):

  def __init__(self):
    pass

  def keys(self):
    """ Returns the keys of the row. """
    pass

SQLITE_ALTER_TABLE = 26
SQLITE_ANALYZE = 28
SQLITE_ATTACH = 24
SQLITE_CREATE_INDEX = 1
SQLITE_CREATE_TABLE = 2
SQLITE_CREATE_TEMP_INDEX = 3
SQLITE_CREATE_TEMP_TABLE = 4
SQLITE_CREATE_TEMP_TRIGGER = 5
SQLITE_CREATE_TEMP_VIEW = 6
SQLITE_CREATE_TRIGGER = 7
SQLITE_CREATE_VIEW = 8
SQLITE_DELETE = 9
SQLITE_DENY = 1
SQLITE_DETACH = 25
SQLITE_DROP_INDEX = 10
SQLITE_DROP_TABLE = 11
SQLITE_DROP_TEMP_INDEX = 12
SQLITE_DROP_TEMP_TABLE = 13
SQLITE_DROP_TEMP_TRIGGER = 14
SQLITE_DROP_TEMP_VIEW = 15
SQLITE_DROP_TRIGGER = 16
SQLITE_DROP_VIEW = 17
SQLITE_IGNORE = 2
SQLITE_INSERT = 18
SQLITE_OK = 0
SQLITE_PRAGMA = 19
SQLITE_READ = 20
SQLITE_REINDEX = 27
SQLITE_SELECT = 21
SQLITE_TRANSACTION = 22
SQLITE_UPDATE = 23

class Statement(object):

  pass

class Warning(Exception):

  pass

__doc__ = None
__file__ = '/Users/Shared/src/ide/build-files/build-temp/runtimes-release/__os__/osx/runtime-python3.3/lib/Python.framework/Versions/Current/lib/python3.3/lib-dynload/_sqlite3.so'
__loader__ = None
__name__ = '_sqlite3'
__package__ = ''

def adapt(obj, protocol, alternate):
  """ adapt(obj, protocol, alternate) -> adapt obj to given protocol. Non-standard. """
  return None

adapters = {}

def complete_statement(sql):
  """ complete_statement(sql)
  
  Checks if a string contains a complete SQL statement. Non-standard. """
  pass

def connect(database, timeout=None, isolation_level=None, detect_types=None, factory=None):
  """ connect(database[, timeout, isolation_level, detect_types, factory])
  
  Opens a connection to the SQLite database file *database*. You can use
  ":memory:" to open a database connection to a database that resides in
  RAM instead of on disk. """
  pass

converters = {}

def enable_callback_tracebacks(flag):
  """ enable_callback_tracebacks(flag)
  
  Enable or disable callback functions throwing errors to stderr. """
  pass

def enable_shared_cache(do_enable):
  """ enable_shared_cache(do_enable)
  
  Enable or disable shared cache mode for the calling thread.
  Experimental/Non-standard. """
  pass

def register_adapter(type, callable):
  """ register_adapter(type, callable)
  
  Registers an adapter with pysqlite's adapter registry. Non-standard. """
  pass

def register_converter(typename, callable):
  """ register_converter(typename, callable)
  
  Registers a converter with pysqlite. Non-standard. """
  pass

sqlite_version = '3.24.0'
version = '2.6.0'