diff options
41 files changed, 690 insertions, 876 deletions
diff --git a/Demo/classes/Dbm.py b/Demo/classes/Dbm.py index 617fe99..f931e93 100755 --- a/Demo/classes/Dbm.py +++ b/Demo/classes/Dbm.py @@ -7,8 +7,8 @@ class Dbm: def __init__(self, filename, mode, perm): - import dbm - self.db = dbm.open(filename, mode, perm) + import dbm.ndbm + self.db = dbm.ndbm.open(filename, mode, perm) def __repr__(self): s = '' diff --git a/Doc/distutils/setupscript.rst b/Doc/distutils/setupscript.rst index 3cc1da9..616b99c 100644 --- a/Doc/distutils/setupscript.rst +++ b/Doc/distutils/setupscript.rst @@ -316,7 +316,7 @@ For example, if you need to link against libraries known to be in the standard library search path on target systems :: Extension(..., - libraries=['gdbm', 'readline']) + libraries=['_gdbm', 'readline']) If you need to link with libraries in a non-standard location, you'll have to include the location in ``library_dirs``:: diff --git a/Doc/library/anydbm.rst b/Doc/library/anydbm.rst deleted file mode 100644 index f35a416..0000000 --- a/Doc/library/anydbm.rst +++ /dev/null @@ -1,96 +0,0 @@ - -:mod:`anydbm` --- Generic access to DBM-style databases -======================================================= - -.. module:: anydbm - :synopsis: Generic interface to DBM-style database modules. - - -.. index:: - module: dbhash - module: bsddb - module: gdbm - module: dbm - module: dumbdbm - -:mod:`anydbm` is a generic interface to variants of the DBM database --- -:mod:`dbhash` (requires :mod:`bsddb`), :mod:`gdbm`, or :mod:`dbm`. If none of -these modules is installed, the slow-but-simple implementation in module -:mod:`dumbdbm` will be used. - - -.. function:: open(filename[, flag[, mode]]) - - Open the database file *filename* and return a corresponding object. - - If the database file already exists, the :mod:`whichdb` module is used to - determine its type and the appropriate module is used; if it does not exist, the - first module listed above that can be imported is used. - - The optional *flag* argument can be ``'r'`` to open an existing database for - reading only, ``'w'`` to open an existing database for reading and writing, - ``'c'`` to create the database if it doesn't exist, or ``'n'``, which will - always create a new empty database. If not specified, the default value is - ``'r'``. - - The optional *mode* argument is the Unix mode of the file, used only when the - database has to be created. It defaults to octal ``0666`` (and will be modified - by the prevailing umask). - - -.. exception:: error - - A tuple containing the exceptions that can be raised by each of the supported - modules, with a unique exception also named :exc:`anydbm.error` as the first - item --- the latter is used when :exc:`anydbm.error` is raised. - -The object returned by :func:`open` supports most of the same functionality as -dictionaries; keys and their corresponding values can be stored, retrieved, and -deleted, and the :meth:`has_key` and :meth:`keys` methods are available. Keys -and values must always be strings. - -The following example records some hostnames and a corresponding title, and -then prints out the contents of the database:: - - import anydbm - - # Open database, creating it if necessary. - db = anydbm.open('cache', 'c') - - # Record some values - db['www.python.org'] = 'Python Website' - db['www.cnn.com'] = 'Cable News Network' - - # Loop through contents. Other dictionary methods - # such as .keys(), .values() also work. - for k, v in db.iteritems(): - print(k, '\t', v) - - # Storing a non-string key or value will raise an exception (most - # likely a TypeError). - db['www.yahoo.com'] = 4 - - # Close when done. - db.close() - - -.. seealso:: - - Module :mod:`dbhash` - BSD ``db`` database interface. - - Module :mod:`dbm` - Standard Unix database interface. - - Module :mod:`dumbdbm` - Portable implementation of the ``dbm`` interface. - - Module :mod:`gdbm` - GNU database interface, based on the ``dbm`` interface. - - Module :mod:`shelve` - General object persistence built on top of the Python ``dbm`` interface. - - Module :mod:`whichdb` - Utility module used to determine the type of an existing database. - diff --git a/Doc/library/bsddb.rst b/Doc/library/bsddb.rst index 1b153c9..9fde725 100644 --- a/Doc/library/bsddb.rst +++ b/Doc/library/bsddb.rst @@ -92,7 +92,7 @@ arguments should be used in most instances. .. seealso:: - Module :mod:`dbhash` + Module :mod:`dbm.bsd` DBM-style interface to the :mod:`bsddb` diff --git a/Doc/library/dbhash.rst b/Doc/library/dbhash.rst deleted file mode 100644 index aadb14f..0000000 --- a/Doc/library/dbhash.rst +++ /dev/null @@ -1,114 +0,0 @@ - -:mod:`dbhash` --- DBM-style interface to the BSD database library -================================================================= - -.. module:: dbhash - :synopsis: DBM-style interface to the BSD database library. -.. sectionauthor:: Fred L. Drake, Jr. <fdrake@acm.org> - - -.. index:: module: bsddb - -The :mod:`dbhash` module provides a function to open databases using the BSD -``db`` library. This module mirrors the interface of the other Python database -modules that provide access to DBM-style databases. The :mod:`bsddb` module is -required to use :mod:`dbhash`. - -This module provides an exception and a function: - - -.. exception:: error - - Exception raised on database errors other than :exc:`KeyError`. It is a synonym - for :exc:`bsddb.error`. - - -.. function:: open(path[, flag[, mode]]) - - Open a ``db`` database and return the database object. The *path* argument is - the name of the database file. - - The *flag* argument can be: - - +---------+-------------------------------------------+ - | Value | Meaning | - +=========+===========================================+ - | ``'r'`` | Open existing database for reading only | - | | (default) | - +---------+-------------------------------------------+ - | ``'w'`` | Open existing database for reading and | - | | writing | - +---------+-------------------------------------------+ - | ``'c'`` | Open database for reading and writing, | - | | creating it if it doesn't exist | - +---------+-------------------------------------------+ - | ``'n'`` | Always create a new, empty database, open | - | | for reading and writing | - +---------+-------------------------------------------+ - - For platforms on which the BSD ``db`` library supports locking, an ``'l'`` - can be appended to indicate that locking should be used. - - The optional *mode* parameter is used to indicate the Unix permission bits that - should be set if a new database must be created; this will be masked by the - current umask value for the process. - - -.. seealso:: - - Module :mod:`anydbm` - Generic interface to ``dbm``\ -style databases. - - Module :mod:`bsddb` - Lower-level interface to the BSD ``db`` library. - - Module :mod:`whichdb` - Utility module used to determine the type of an existing database. - - -.. _dbhash-objects: - -Database Objects ----------------- - -The database objects returned by :func:`open` provide the methods common to all -the DBM-style databases and mapping objects. The following methods are -available in addition to the standard methods. - - -.. method:: dbhash.first() - - It's possible to loop over every key/value pair in the database using this - method and the :meth:`next` method. The traversal is ordered by the databases - internal hash values, and won't be sorted by the key values. This method - returns the starting key. - - -.. method:: dbhash.last() - - Return the last key/value pair in a database traversal. This may be used to - begin a reverse-order traversal; see :meth:`previous`. - - -.. method:: dbhash.next() - - Returns the key next key/value pair in a database traversal. The following code - prints every key in the database ``db``, without having to create a list in - memory that contains them all:: - - print(db.first()) - for i in range(1, len(db)): - print(db.next()) - - -.. method:: dbhash.previous() - - Returns the previous key/value pair in a forward-traversal of the database. In - conjunction with :meth:`last`, this may be used to implement a reverse-order - traversal. - - -.. method:: dbhash.sync() - - This method forces any unwritten data to be written to the disk. - diff --git a/Doc/library/dbm.rst b/Doc/library/dbm.rst index 52923e8..2a314dc 100644 --- a/Doc/library/dbm.rst +++ b/Doc/library/dbm.rst @@ -1,14 +1,294 @@ - -:mod:`dbm` --- Simple "database" interface -========================================== +:mod:`dbm` --- Interfaces to Unix "databases" +============================================= .. module:: dbm + :synopsis: Interfaces to various Unix "database" formats. + +:mod:`dbm` is a generic interface to variants of the DBM database --- +:mod:`dbm.bsd` (requires :mod:`bsddb`), :mod:`dbm.gnu`, or :mod:`dbm.ndbm`. If +none of these modules is installed, the slow-but-simple implementation in module +:mod:`dbm.dumb` will be used. + + +.. exception:: error + + A tuple containing the exceptions that can be raised by each of the supported + modules, with a unique exception also named :exc:`dbm.error` as the first + item --- the latter is used when :exc:`dbm.error` is raised. + + +.. function:: whichdb(filename) + + This functionattempts to guess which of the several simple database modules + available --- :mod:`dbm.bsd`, :mod:`dbm.gnu`, :mod:`dbm.ndbm` or + :mod:`dbm.dumb` --- should be used to open a given file. + + Returns one of the following values: ``None`` if the file can't be opened + because it's unreadable or doesn't exist; the empty string (``''``) if the + file's format can't be guessed; or a string containing the required module + name, such as ``'dbm.ndbm'`` or ``'dbm.gnu'``. + + +.. function:: open(filename[, flag[, mode]]) + + Open the database file *filename* and return a corresponding object. + + If the database file already exists, the :func:`whichdb` function is used to + determine its type and the appropriate module is used; if it does not exist, + the first module listed above that can be imported is used. + + The optional *flag* argument can be ``'r'`` to open an existing database for + reading only, ``'w'`` to open an existing database for reading and writing, + ``'c'`` to create the database if it doesn't exist, or ``'n'``, which will + always create a new empty database. If not specified, the default value is + ``'r'``. + + The optional *mode* argument is the Unix mode of the file, used only when the + database has to be created. It defaults to octal ``0o666`` (and will be + modified by the prevailing umask). + + +The object returned by :func:`open` supports most of the same functionality as +dictionaries; keys and their corresponding values can be stored, retrieved, and +deleted, and the :keyword:`in` operator and the :meth:`keys` method are +available. Keys and values must always be strings. + +The following example records some hostnames and a corresponding title, and +then prints out the contents of the database:: + + import dbm + + # Open database, creating it if necessary. + db = dbm.open('cache', 'c') + + # Record some values + db['www.python.org'] = 'Python Website' + db['www.cnn.com'] = 'Cable News Network' + + # Loop through contents. Other dictionary methods + # such as .keys(), .values() also work. + for k, v in db.iteritems(): + print(k, '\t', v) + + # Storing a non-string key or value will raise an exception (most + # likely a TypeError). + db['www.yahoo.com'] = 4 + + # Close when done. + db.close() + + +.. seealso:: + + Module :mod:`shelve` + Persistence module which stores non-string data. + + +The individual submodules are described in the following sections. + + +:mod:`dbm.bsd` --- DBM-style interface to the BSD database library +------------------------------------------------------------------ + +.. module:: dbm.bsd + :synopsis: DBM-style interface to the BSD database library. +.. sectionauthor:: Fred L. Drake, Jr. <fdrake@acm.org> + +.. index:: module: bsddb + +The :mod:`dbm.bsd` module provides a function to open databases using the BSD +``db`` library. This module mirrors the interface of the other Python database +modules that provide access to DBM-style databases. The :mod:`bsddb` module is +required to use :mod:`dbm.bsd`. + +.. exception:: error + + Exception raised on database errors other than :exc:`KeyError`. It is a synonym + for :exc:`bsddb.error`. + + +.. function:: open(path[, flag[, mode]]) + + Open a ``db`` database and return the database object. The *path* argument is + the name of the database file. + + The *flag* argument can be: + + +---------+-------------------------------------------+ + | Value | Meaning | + +=========+===========================================+ + | ``'r'`` | Open existing database for reading only | + | | (default) | + +---------+-------------------------------------------+ + | ``'w'`` | Open existing database for reading and | + | | writing | + +---------+-------------------------------------------+ + | ``'c'`` | Open database for reading and writing, | + | | creating it if it doesn't exist | + +---------+-------------------------------------------+ + | ``'n'`` | Always create a new, empty database, open | + | | for reading and writing | + +---------+-------------------------------------------+ + + For platforms on which the BSD ``db`` library supports locking, an ``'l'`` + can be appended to indicate that locking should be used. + + The optional *mode* parameter is used to indicate the Unix permission bits that + should be set if a new database must be created; this will be masked by the + current umask value for the process. + + The database objects returned by :func:`open` provide the methods common to all + the DBM-style databases and mapping objects. The following methods are + available in addition to the standard methods: + + .. method:: dbhash.first() + + It's possible to loop over every key/value pair in the database using this + method and the :meth:`next` method. The traversal is ordered by the databases + internal hash values, and won't be sorted by the key values. This method + returns the starting key. + + .. method:: dbhash.last() + + Return the last key/value pair in a database traversal. This may be used to + begin a reverse-order traversal; see :meth:`previous`. + + .. method:: dbhash.next() + + Returns the key next key/value pair in a database traversal. The following code + prints every key in the database ``db``, without having to create a list in + memory that contains them all:: + + print(db.first()) + for i in range(1, len(db)): + print(db.next()) + + .. method:: dbhash.previous() + + Returns the previous key/value pair in a forward-traversal of the database. In + conjunction with :meth:`last`, this may be used to implement a reverse-order + traversal. + + .. method:: dbhash.sync() + + This method forces any unwritten data to be written to the disk. + + +:mod:`dbm.gnu` --- GNU's reinterpretation of dbm +------------------------------------------------ + +.. module:: dbm.gnu + :platform: Unix + :synopsis: GNU's reinterpretation of dbm. + + +This module is quite similar to the :mod:`dbm` module, but uses the GNU library +``gdbm`` instead to provide some additional functionality. Please note that the +file formats created by ``gdbm`` and ``dbm`` are incompatible. + +The :mod:`dbm.gnu` module provides an interface to the GNU DBM library. +``gdbm`` objects behave like mappings (dictionaries), except that keys and +values are always strings. Printing a :mod:`dbm.gnu` object doesn't print the +keys and values, and the :meth:`items` and :meth:`values` methods are not +supported. + +.. exception:: error + + Raised on ``gdbm``\ -specific errors, such as I/O errors. :exc:`KeyError` is + raised for general mapping errors like specifying an incorrect key. + + +.. function:: open(filename, [flag, [mode]]) + + Open a ``gdbm`` database and return a :class:`gdbm` object. The *filename* + argument is the name of the database file. + + The optional *flag* argument can be: + + +---------+-------------------------------------------+ + | Value | Meaning | + +=========+===========================================+ + | ``'r'`` | Open existing database for reading only | + | | (default) | + +---------+-------------------------------------------+ + | ``'w'`` | Open existing database for reading and | + | | writing | + +---------+-------------------------------------------+ + | ``'c'`` | Open database for reading and writing, | + | | creating it if it doesn't exist | + +---------+-------------------------------------------+ + | ``'n'`` | Always create a new, empty database, open | + | | for reading and writing | + +---------+-------------------------------------------+ + + The following additional characters may be appended to the flag to control + how the database is opened: + + +---------+--------------------------------------------+ + | Value | Meaning | + +=========+============================================+ + | ``'f'`` | Open the database in fast mode. Writes | + | | to the database will not be synchronized. | + +---------+--------------------------------------------+ + | ``'s'`` | Synchronized mode. This will cause changes | + | | to the database to be immediately written | + | | to the file. | + +---------+--------------------------------------------+ + | ``'u'`` | Do not lock database. | + +---------+--------------------------------------------+ + + Not all flags are valid for all versions of ``gdbm``. The module constant + :const:`open_flags` is a string of supported flag characters. The exception + :exc:`error` is raised if an invalid flag is specified. + + The optional *mode* argument is the Unix mode of the file, used only when the + database has to be created. It defaults to octal ``0666``. + + In addition to the dictionary-like methods, ``gdbm`` objects have the + following methods: + + .. method:: gdbm.firstkey() + + It's possible to loop over every key in the database using this method and the + :meth:`nextkey` method. The traversal is ordered by ``gdbm``'s internal + hash values, and won't be sorted by the key values. This method returns + the starting key. + + .. method:: gdbm.nextkey(key) + + Returns the key that follows *key* in the traversal. The following code prints + every key in the database ``db``, without having to create a list in memory that + contains them all:: + + k = db.firstkey() + while k != None: + print(k) + k = db.nextkey(k) + + .. method:: gdbm.reorganize() + + If you have carried out a lot of deletions and would like to shrink the space + used by the ``gdbm`` file, this routine will reorganize the database. ``gdbm`` + will not shorten the length of a database file except by using this + reorganization; otherwise, deleted file space will be kept and reused as new + (key, value) pairs are added. + + .. method:: gdbm.sync() + + When the database has been opened in fast mode, this method forces any + unwritten data to be written to the disk. + + +:mod:`dbm.ndbm` --- Interface based on ndbm +------------------------------------------- + +.. module:: dbm.ndbm :platform: Unix :synopsis: The standard "database" interface, based on ndbm. -The :mod:`dbm` module provides an interface to the Unix "(n)dbm" library. Dbm -objects behave like mappings (dictionaries), except that keys and values are +The :mod:`dbm.ndbm` module provides an interface to the Unix "(n)dbm" library. +Dbm objects behave like mappings (dictionaries), except that keys and values are always strings. Printing a dbm object doesn't print the keys and values, and the :meth:`items` and :meth:`values` methods are not supported. @@ -17,13 +297,10 @@ compatibility interface, or the GNU GDBM compatibility interface. On Unix, the :program:`configure` script will attempt to locate the appropriate header file to simplify building this module. -The module defines the following: - - .. exception:: error - Raised on dbm-specific errors, such as I/O errors. :exc:`KeyError` is raised for - general mapping errors like specifying an incorrect key. + Raised on dbm-specific errors, such as I/O errors. :exc:`KeyError` is raised + for general mapping errors like specifying an incorrect key. .. data:: library @@ -61,14 +338,54 @@ The module defines the following: modified by the prevailing umask). -.. seealso:: - Module :mod:`anydbm` - Generic interface to ``dbm``\ -style databases. +:mod:`dbm.dumb` --- Portable DBM implementation +----------------------------------------------- + +.. module:: dbm.dumb + :synopsis: Portable implementation of the simple DBM interface. + +.. index:: single: databases + +.. note:: + + The :mod:`dbm.dumb` module is intended as a last resort fallback for the + :mod:`dbm` module when no more robust module is available. The :mod:`dbm.dumb` + module is not written for speed and is not nearly as heavily used as the other + database modules. + +The :mod:`dbm.dumb` module provides a persistent dictionary-like interface which +is written entirely in Python. Unlike other modules such as :mod:`gdbm` and +:mod:`bsddb`, no external library is required. As with other persistent +mappings, the keys and values must always be strings. + +The module defines the following: + + +.. exception:: error + + Raised on dbm.dumb-specific errors, such as I/O errors. :exc:`KeyError` is + raised for general mapping errors like specifying an incorrect key. + + +.. function:: open(filename[, flag[, mode]]) + + Open a dumbdbm database and return a dumbdbm object. The *filename* argument is + the basename of the database file (without any specific extensions). When a + dumbdbm database is created, files with :file:`.dat` and :file:`.dir` extensions + are created. + + The optional *flag* argument is currently ignored; the database is always opened + for update, and will be created if it does not exist. + + The optional *mode* argument is the Unix mode of the file, used only when the + database has to be created. It defaults to octal ``0o666`` (and will be modified + by the prevailing umask). - Module :mod:`gdbm` - Similar interface to the GNU GDBM library. + In addition to the methods provided by the :class:`collections.MutableMapping` class, + :class:`dumbdbm` objects provide the following method: - Module :mod:`whichdb` - Utility module used to determine the type of an existing database. + .. method:: dumbdbm.sync() + Synchronize the on-disk directory and data files. This method is called + by the :meth:`Shelve.sync` method. diff --git a/Doc/library/dumbdbm.rst b/Doc/library/dumbdbm.rst deleted file mode 100644 index 4e91ac9..0000000 --- a/Doc/library/dumbdbm.rst +++ /dev/null @@ -1,78 +0,0 @@ - -:mod:`dumbdbm` --- Portable DBM implementation -============================================== - -.. module:: dumbdbm - :synopsis: Portable implementation of the simple DBM interface. - - -.. index:: single: databases - -.. note:: - - The :mod:`dumbdbm` module is intended as a last resort fallback for the - :mod:`anydbm` module when no more robust module is available. The :mod:`dumbdbm` - module is not written for speed and is not nearly as heavily used as the other - database modules. - -The :mod:`dumbdbm` module provides a persistent dictionary-like interface which -is written entirely in Python. Unlike other modules such as :mod:`gdbm` and -:mod:`bsddb`, no external library is required. As with other persistent -mappings, the keys and values must always be strings. - -The module defines the following: - - -.. exception:: error - - Raised on dumbdbm-specific errors, such as I/O errors. :exc:`KeyError` is - raised for general mapping errors like specifying an incorrect key. - - -.. function:: open(filename[, flag[, mode]]) - - Open a dumbdbm database and return a dumbdbm object. The *filename* argument is - the basename of the database file (without any specific extensions). When a - dumbdbm database is created, files with :file:`.dat` and :file:`.dir` extensions - are created. - - The optional *flag* argument is currently ignored; the database is always opened - for update, and will be created if it does not exist. - - The optional *mode* argument is the Unix mode of the file, used only when the - database has to be created. It defaults to octal ``0666`` (and will be modified - by the prevailing umask). - - -.. seealso:: - - Module :mod:`anydbm` - Generic interface to ``dbm``\ -style databases. - - Module :mod:`dbm` - Similar interface to the DBM/NDBM library. - - Module :mod:`gdbm` - Similar interface to the GNU GDBM library. - - Module :mod:`shelve` - Persistence module which stores non-string data. - - Module :mod:`whichdb` - Utility module used to determine the type of an existing database. - - -.. _dumbdbm-objects: - -Dumbdbm Objects ---------------- - -In addition to the methods provided by the :class:`UserDict.DictMixin` class, -:class:`dumbdbm` objects provide the following methods. - - -.. method:: dumbdbm.sync() - - Synchronize the on-disk directory and data files. This method is called by the - :meth:`sync` method of :class:`Shelve` objects. - diff --git a/Doc/library/gdbm.rst b/Doc/library/gdbm.rst deleted file mode 100644 index f69e667..0000000 --- a/Doc/library/gdbm.rst +++ /dev/null @@ -1,122 +0,0 @@ - -:mod:`gdbm` --- GNU's reinterpretation of dbm -============================================= - -.. module:: gdbm - :platform: Unix - :synopsis: GNU's reinterpretation of dbm. - - -.. index:: module: dbm - -This module is quite similar to the :mod:`dbm` module, but uses ``gdbm`` instead -to provide some additional functionality. Please note that the file formats -created by ``gdbm`` and ``dbm`` are incompatible. - -The :mod:`gdbm` module provides an interface to the GNU DBM library. ``gdbm`` -objects behave like mappings (dictionaries), except that keys and values are -always strings. Printing a ``gdbm`` object doesn't print the keys and values, -and the :meth:`items` and :meth:`values` methods are not supported. - -The module defines the following constant and functions: - - -.. exception:: error - - Raised on ``gdbm``\ -specific errors, such as I/O errors. :exc:`KeyError` is - raised for general mapping errors like specifying an incorrect key. - - -.. function:: open(filename, [flag, [mode]]) - - Open a ``gdbm`` database and return a ``gdbm`` object. The *filename* argument - is the name of the database file. - - The optional *flag* argument can be: - - +---------+-------------------------------------------+ - | Value | Meaning | - +=========+===========================================+ - | ``'r'`` | Open existing database for reading only | - | | (default) | - +---------+-------------------------------------------+ - | ``'w'`` | Open existing database for reading and | - | | writing | - +---------+-------------------------------------------+ - | ``'c'`` | Open database for reading and writing, | - | | creating it if it doesn't exist | - +---------+-------------------------------------------+ - | ``'n'`` | Always create a new, empty database, open | - | | for reading and writing | - +---------+-------------------------------------------+ - - The following additional characters may be appended to the flag to control - how the database is opened: - - +---------+--------------------------------------------+ - | Value | Meaning | - +=========+============================================+ - | ``'f'`` | Open the database in fast mode. Writes | - | | to the database will not be synchronized. | - +---------+--------------------------------------------+ - | ``'s'`` | Synchronized mode. This will cause changes | - | | to the database to be immediately written | - | | to the file. | - +---------+--------------------------------------------+ - | ``'u'`` | Do not lock database. | - +---------+--------------------------------------------+ - - Not all flags are valid for all versions of ``gdbm``. The module constant - :const:`open_flags` is a string of supported flag characters. The exception - :exc:`error` is raised if an invalid flag is specified. - - The optional *mode* argument is the Unix mode of the file, used only when the - database has to be created. It defaults to octal ``0666``. - -In addition to the dictionary-like methods, ``gdbm`` objects have the following -methods: - - -.. function:: firstkey() - - It's possible to loop over every key in the database using this method and the - :meth:`nextkey` method. The traversal is ordered by ``gdbm``'s internal hash - values, and won't be sorted by the key values. This method returns the starting - key. - - -.. function:: nextkey(key) - - Returns the key that follows *key* in the traversal. The following code prints - every key in the database ``db``, without having to create a list in memory that - contains them all:: - - k = db.firstkey() - while k != None: - print(k) - k = db.nextkey(k) - - -.. function:: reorganize() - - If you have carried out a lot of deletions and would like to shrink the space - used by the ``gdbm`` file, this routine will reorganize the database. ``gdbm`` - will not shorten the length of a database file except by using this - reorganization; otherwise, deleted file space will be kept and reused as new - (key, value) pairs are added. - - -.. function:: sync() - - When the database has been opened in fast mode, this method forces any - unwritten data to be written to the disk. - - -.. seealso:: - - Module :mod:`anydbm` - Generic interface to ``dbm``\ -style databases. - - Module :mod:`whichdb` - Utility module used to determine the type of an existing database. - diff --git a/Doc/library/persistence.rst b/Doc/library/persistence.rst index 3708d17..c5c2aa4 100644 --- a/Doc/library/persistence.rst +++ b/Doc/library/persistence.rst @@ -22,11 +22,5 @@ The list of modules described in this chapter is: copyreg.rst shelve.rst marshal.rst - anydbm.rst - whichdb.rst dbm.rst - gdbm.rst - dbhash.rst - bsddb.rst - dumbdbm.rst sqlite3.rst diff --git a/Doc/library/shelve.rst b/Doc/library/shelve.rst index 262b4a4..ee839e8 100644 --- a/Doc/library/shelve.rst +++ b/Doc/library/shelve.rst @@ -21,7 +21,7 @@ lots of shared sub-objects. The keys are ordinary strings. the underlying database. As a side-effect, an extension may be added to the filename and more than one file may be created. By default, the underlying database file is opened for reading and writing. The optional *flag* parameter - has the same interpretation as the *flag* parameter of :func:`anydbm.open`. + has the same interpretation as the *flag* parameter of :func:`dbm.open`. By default, version 0 pickles are used to serialize values. The version of the pickle protocol can be specified with the *protocol* parameter. @@ -53,12 +53,12 @@ Restrictions ------------ .. index:: - module: dbm - module: gdbm + module: dbm.ndbm + module: dbm.gnu module: bsddb -* The choice of which database package will be used (such as :mod:`dbm`, - :mod:`gdbm` or :mod:`bsddb`) depends on which interface is available. Therefore +* The choice of which database package will be used (such as :mod:`dbm.ndbm`, + :mod:`dbm.gnu` or :mod:`bsddb`) depends on which interface is available. Therefore it is not safe to open the database directly using :mod:`dbm`. The database is also (unfortunately) subject to the limitations of :mod:`dbm`, if it is used --- this means that (the pickled representation of) the objects stored in the @@ -107,7 +107,7 @@ Restrictions .. class:: DbfilenameShelf(filename[, flag='c'[, protocol=None[, writeback=False]]]) A subclass of :class:`Shelf` which accepts a *filename* instead of a dict-like - object. The underlying file will be opened using :func:`anydbm.open`. By + object. The underlying file will be opened using :func:`dbm.open`. By default, the file will be created and opened for both read and write. The optional *flag* parameter has the same interpretation as for the :func:`open` function. The optional *protocol* and *writeback* parameters have the same @@ -152,25 +152,12 @@ object):: .. seealso:: - Module :mod:`anydbm` - Generic interface to ``dbm``\ -style databases. + Module :mod:`dbm` + Generic interface to ``dbm``-style databases. Module :mod:`bsddb` BSD ``db`` database interface. - Module :mod:`dbhash` - Thin layer around the :mod:`bsddb` which provides an :func:`open` function like - the other database modules. - - Module :mod:`dbm` - Standard Unix database interface. - - Module :mod:`dumbdbm` - Portable implementation of the ``dbm`` interface. - - Module :mod:`gdbm` - GNU database interface, based on the ``dbm`` interface. - Module :mod:`pickle` Object serialization used by :mod:`shelve`. diff --git a/Doc/library/whichdb.rst b/Doc/library/whichdb.rst deleted file mode 100644 index 5c69818..0000000 --- a/Doc/library/whichdb.rst +++ /dev/null @@ -1,20 +0,0 @@ - -:mod:`whichdb` --- Guess which DBM module created a database -============================================================ - -.. module:: whichdb - :synopsis: Guess which DBM-style module created a given database. - - -The single function in this module attempts to guess which of the several simple -database modules available--\ :mod:`dbm`, :mod:`gdbm`, or :mod:`dbhash`\ ---should be used to open a given file. - - -.. function:: whichdb(filename) - - Returns one of the following values: ``None`` if the file can't be opened - because it's unreadable or doesn't exist; the empty string (``''``) if the - file's format can't be guessed; or a string containing the required module name, - such as ``'dbm'`` or ``'gdbm'``. - diff --git a/Doc/reference/datamodel.rst b/Doc/reference/datamodel.rst index 3912d1e..7460dce8 100644 --- a/Doc/reference/datamodel.rst +++ b/Doc/reference/datamodel.rst @@ -394,12 +394,12 @@ Mappings section :ref:`dict`). .. index:: - module: dbm - module: gdbm + module: dbm.ndbm + module: dbm.gnu module: bsddb - The extension modules :mod:`dbm`, :mod:`gdbm`, and :mod:`bsddb` provide - additional examples of mapping types. + The extension modules :mod:`dbm.ndbm`, :mod:`dbm.gnu`, and :mod:`bsddb` + provide additional examples of mapping types. Callable types .. index:: diff --git a/Lib/anydbm.py b/Lib/anydbm.py deleted file mode 100644 index 41335a3..0000000 --- a/Lib/anydbm.py +++ /dev/null @@ -1,83 +0,0 @@ -"""Generic interface to all dbm clones. - -Instead of - - import dbm - d = dbm.open(file, 'w', 0o666) - -use - - import anydbm - d = anydbm.open(file, 'w') - -The returned object is a dbhash, gdbm, dbm or dumbdbm object, -dependent on the type of database being opened (determined by whichdb -module) in the case of an existing dbm. If the dbm does not exist and -the create or new flag ('c' or 'n') was specified, the dbm type will -be determined by the availability of the modules (tested in the above -order). - -It has the following interface (key and data are strings): - - d[key] = data # store data at key (may override data at - # existing key) - data = d[key] # retrieve data at key (raise KeyError if no - # such key) - del d[key] # delete data stored at key (raises KeyError - # if no such key) - flag = key in d # true if the key exists - list = d.keys() # return a list of all existing keys (slow!) - -Future versions may change the order in which implementations are -tested for existence, add interfaces to other dbm-like -implementations. - -The open function has an optional second argument. This can be 'r', -for read-only access, 'w', for read-write access of an existing -database, 'c' for read-write access to a new or existing database, and -'n' for read-write access to a new database. The default is 'r'. - -Note: 'r' and 'w' fail if the database doesn't exist; 'c' creates it -only if it doesn't exist; and 'n' always creates a new database. - -""" - -class error(Exception): - pass - -_names = ['dbhash', 'gdbm', 'dbm', 'dumbdbm'] -_errors = [error] -_defaultmod = None - -for _name in _names: - try: - _mod = __import__(_name) - except ImportError: - continue - if not _defaultmod: - _defaultmod = _mod - _errors.append(_mod.error) - -if not _defaultmod: - raise ImportError("no dbm clone found; tried %s" % _names) - -error = tuple(_errors) - -def open(file, flag = 'r', mode = 0o666): - # guess the type of an existing database - from whichdb import whichdb - result=whichdb(file) - if result is None: - # db doesn't exist - if 'c' in flag or 'n' in flag: - # file doesn't exist and the new - # flag was used so use default type - mod = _defaultmod - else: - raise error("need 'c' or 'n' flag to open new db") - elif result == "": - # db type cannot be determined - raise error("db type could not be determined") - else: - mod = __import__(result) - return mod.open(file, flag, mode) diff --git a/Lib/dbhash.py b/Lib/dbhash.py deleted file mode 100644 index 3c60812..0000000 --- a/Lib/dbhash.py +++ /dev/null @@ -1,16 +0,0 @@ -"""Provide a (g)dbm-compatible interface to bsddb.hashopen.""" - -import sys -try: - import bsddb -except ImportError: - # prevent a second import of this module from spuriously succeeding - del sys.modules[__name__] - raise - -__all__ = ["error","open"] - -error = bsddb.error # Exported for anydbm - -def open(file, flag = 'r', mode=0o666): - return bsddb.hashopen(file, flag, mode) diff --git a/Lib/dbm/__init__.py b/Lib/dbm/__init__.py new file mode 100644 index 0000000..9fdd414 --- /dev/null +++ b/Lib/dbm/__init__.py @@ -0,0 +1,198 @@ +"""Generic interface to all dbm clones. + +Use + + import dbm + d = dbm.open(file, 'w', 0o666) + +The returned object is a dbm.bsd, dbm.gnu, dbm.ndbm or dbm.dumb +object, dependent on the type of database being opened (determined by +the whichdb function) in the case of an existing dbm. If the dbm does +not exist and the create or new flag ('c' or 'n') was specified, the +dbm type will be determined by the availability of the modules (tested +in the above order). + +It has the following interface (key and data are strings): + + d[key] = data # store data at key (may override data at + # existing key) + data = d[key] # retrieve data at key (raise KeyError if no + # such key) + del d[key] # delete data stored at key (raises KeyError + # if no such key) + flag = key in d # true if the key exists + list = d.keys() # return a list of all existing keys (slow!) + +Future versions may change the order in which implementations are +tested for existence, add interfaces to other dbm-like +implementations. + +The open function has an optional second argument. This can be 'r', +for read-only access, 'w', for read-write access of an existing +database, 'c' for read-write access to a new or existing database, and +'n' for read-write access to a new database. The default is 'r'. + +Note: 'r' and 'w' fail if the database doesn't exist; 'c' creates it +only if it doesn't exist; and 'n' always creates a new database. +""" + +__all__ = ['open', 'whichdb', 'error', 'errors'] + +import io +import os +import struct +import sys + + +class error(Exception): + pass + +_names = ['dbm.bsd', 'dbm.gnu', 'dbm.ndbm', 'dbm.dumb'] +_errors = [error] +_defaultmod = None +_modules = {} + +for _name in _names: + try: + _mod = __import__(_name, fromlist=['open']) + except ImportError: + continue + if not _defaultmod: + _defaultmod = _mod + _modules[_name] = _mod + _errors.append(_mod.error) + +if not _defaultmod: + raise ImportError("no dbm clone found; tried %s" % _names) + +error = tuple(_errors) + + +def open(file, flag = 'r', mode = 0o666): + # guess the type of an existing database + result = whichdb(file) + if result is None: + # db doesn't exist + if 'c' in flag or 'n' in flag: + # file doesn't exist and the new flag was used so use default type + mod = _defaultmod + else: + raise error("need 'c' or 'n' flag to open new db") + elif result == "": + # db type cannot be determined + raise error("db type could not be determined") + else: + mod = _modules[result] + return mod.open(file, flag, mode) + + +try: + from dbm import ndbm + _dbmerror = ndbm.error +except ImportError: + ndbm = None + # just some sort of valid exception which might be raised in the ndbm test + _dbmerror = IOError + +def whichdb(filename): + """Guess which db package to use to open a db file. + + Return values: + + - None if the database file can't be read; + - empty string if the file can be read but can't be recognized + - the name of the dbm submodule (e.g. "ndbm" or "gnu") if recognized. + + Importing the given module may still fail, and opening the + database using that module may still fail. + """ + + # Check for ndbm first -- this has a .pag and a .dir file + try: + f = io.open(filename + ".pag", "rb") + f.close() + # dbm linked with gdbm on OS/2 doesn't have .dir file + if not (ndbm.library == "GNU gdbm" and sys.platform == "os2emx"): + f = io.open(filename + ".dir", "rb") + f.close() + return "dbm.ndbm" + except IOError: + # some dbm emulations based on Berkeley DB generate a .db file + # some do not, but they should be caught by the bsd checks + try: + f = io.open(filename + ".db", "rb") + f.close() + # guarantee we can actually open the file using dbm + # kind of overkill, but since we are dealing with emulations + # it seems like a prudent step + if ndbm is not None: + d = ndbm.open(filename) + d.close() + return "dbm.ndbm" + except (IOError, _dbmerror): + pass + + # Check for dumbdbm next -- this has a .dir and a .dat file + try: + # First check for presence of files + os.stat(filename + ".dat") + size = os.stat(filename + ".dir").st_size + # dumbdbm files with no keys are empty + if size == 0: + return "dbm.dumb" + f = io.open(filename + ".dir", "rb") + try: + if f.read(1) in (b"'", b'"'): + return "dbm.dumb" + finally: + f.close() + except (OSError, IOError): + pass + + # See if the file exists, return None if not + try: + f = io.open(filename, "rb") + except IOError: + return None + + # Read the start of the file -- the magic number + s16 = f.read(16) + f.close() + s = s16[0:4] + + # Return "" if not at least 4 bytes + if len(s) != 4: + return "" + + # Convert to 4-byte int in native byte order -- return "" if impossible + try: + (magic,) = struct.unpack("=l", s) + except struct.error: + return "" + + # Check for GNU dbm + if magic == 0x13579ace: + return "dbm.gnu" + + ## Check for old Berkeley db hash file format v2 + #if magic in (0x00061561, 0x61150600): + # return "bsddb185" # not supported anymore + + # Later versions of Berkeley db hash file have a 12-byte pad in + # front of the file type + try: + (magic,) = struct.unpack("=l", s16[-4:]) + except struct.error: + return "" + + # Check for BSD hash + if magic in (0x00061561, 0x61150600): + return "dbm.bsd" + + # Unknown + return "" + + +if __name__ == "__main__": + for filename in sys.argv[1:]: + print(whichdb(filename) or "UNKNOWN", filename) diff --git a/Lib/dbm/bsd.py b/Lib/dbm/bsd.py new file mode 100644 index 0000000..8353f50 --- /dev/null +++ b/Lib/dbm/bsd.py @@ -0,0 +1,10 @@ +"""Provide a (g)dbm-compatible interface to bsddb.hashopen.""" + +import bsddb + +__all__ = ["error", "open"] + +error = bsddb.error + +def open(file, flag = 'r', mode=0o666): + return bsddb.hashopen(file, flag, mode) diff --git a/Lib/dumbdbm.py b/Lib/dbm/dumb.py index 8d58f87..76f4a63 100644 --- a/Lib/dumbdbm.py +++ b/Lib/dbm/dumb.py @@ -25,9 +25,11 @@ import io as _io import os as _os import collections +__all__ = ["error", "open"] + _BLOCKSIZE = 512 -error = IOError # For anydbm +error = IOError class _Database(collections.MutableMapping): @@ -231,7 +233,7 @@ def open(file, flag=None, mode=0o666): """Open the database file, filename, and return corresponding object. The flag argument, used to control how the database is opened in the - other DBM implementations, is ignored in the dumbdbm module; the + other DBM implementations, is ignored in the dbm.dumb module; the database is always opened for update, and will be created if it does not exist. diff --git a/Lib/dbm/gnu.py b/Lib/dbm/gnu.py new file mode 100644 index 0000000..b07a1de --- /dev/null +++ b/Lib/dbm/gnu.py @@ -0,0 +1,3 @@ +"""Provide the _gdbm module as a dbm submodule.""" + +from _gdbm import * diff --git a/Lib/dbm/ndbm.py b/Lib/dbm/ndbm.py new file mode 100644 index 0000000..23056a2 --- /dev/null +++ b/Lib/dbm/ndbm.py @@ -0,0 +1,3 @@ +"""Provide the _dbm module as a dbm submodule.""" + +from _dbm import * @@ -270,7 +270,7 @@ class OpenWrapper: """Wrapper for builtins.open Trick so that open won't become a bound method when stored - as a class variable (as dumbdbm does). + as a class variable (as dbm.dumb does). See initstdio() in Python/pythonrun.c. """ diff --git a/Lib/shelve.py b/Lib/shelve.py index e6d6d40..d651b9e 100644 --- a/Lib/shelve.py +++ b/Lib/shelve.py @@ -190,15 +190,15 @@ class BsdDbShelf(Shelf): class DbfilenameShelf(Shelf): - """Shelf implementation using the "anydbm" generic dbm interface. + """Shelf implementation using the "dbm" generic dbm interface. This is initialized with the filename for the dbm database. See the module's __doc__ string for an overview of the interface. """ def __init__(self, filename, flag='c', protocol=None, writeback=False): - import anydbm - Shelf.__init__(self, anydbm.open(filename, flag), protocol, writeback) + import dbm + Shelf.__init__(self, dbm.open(filename, flag), protocol, writeback) def open(filename, flag='c', protocol=None, writeback=False): @@ -208,7 +208,7 @@ def open(filename, flag='c', protocol=None, writeback=False): database. As a side-effect, an extension may be added to the filename and more than one file may be created. The optional flag parameter has the same interpretation as the flag parameter of - anydbm.open(). The optional protocol parameter specifies the + dbm.open(). The optional protocol parameter specifies the version of the pickle protocol (0, 1, or 2). See the module's __doc__ string for an overview of the interface. diff --git a/Lib/test/test___all__.py b/Lib/test/test___all__.py index 615f6c5..ed8d8d9 100644 --- a/Lib/test/test___all__.py +++ b/Lib/test/test___all__.py @@ -57,7 +57,7 @@ class AllTest(unittest.TestCase): self.check_all("copy") self.check_all("copyreg") self.check_all("csv") - self.check_all("dbhash") + self.check_all("dbm.bsd") self.check_all("decimal") self.check_all("difflib") self.check_all("dircache") diff --git a/Lib/test/test_anydbm.py b/Lib/test/test_anydbm.py index ace9dd2..aab1388 100644 --- a/Lib/test/test_anydbm.py +++ b/Lib/test/test_anydbm.py @@ -1,50 +1,34 @@ #! /usr/bin/env python -"""Test script for the anydbm module - based on testdumbdbm.py -""" +"""Test script for the dbm.open function based on testdumbdbm.py""" import os import unittest -import anydbm +import dbm import glob -from test import support - -_fname = support.TESTFN - -_all_modules = [] - -for _name in anydbm._names: - try: - _module = __import__(_name) - except ImportError: - continue - _all_modules.append(_module) +import test.support +_fname = test.support.TESTFN # -# Iterates over every database module supported by anydbm -# currently available, setting anydbm to use each in turn, -# and yielding that module +# Iterates over every database module supported by dbm currently available, +# setting dbm to use each in turn, and yielding that module # def dbm_iterator(): - old_default = anydbm._defaultmod - for module in _all_modules: - anydbm._defaultmod = module + old_default = dbm._defaultmod + for module in dbm._modules.values(): + dbm._defaultmod = module yield module - anydbm._defaultmod = old_default + dbm._defaultmod = old_default # -# Clean up all scratch databases we might have created -# during testing +# Clean up all scratch databases we might have created during testing # def delete_files(): # we don't know the precise name the underlying database uses # so we use glob to locate all names for f in glob.glob(_fname + "*"): - try: - os.unlink(f) - except OSError: - pass + test.support.unlink(f) + class AnyDBMTestCase(unittest.TestCase): _dict = {'0': b'', @@ -60,7 +44,7 @@ class AnyDBMTestCase(unittest.TestCase): unittest.TestCase.__init__(self, *args) def test_anydbm_creation(self): - f = anydbm.open(_fname, 'c') + f = dbm.open(_fname, 'c') self.assertEqual(list(f.keys()), []) for key in self._dict: f[key.encode("ascii")] = self._dict[key] @@ -69,26 +53,26 @@ class AnyDBMTestCase(unittest.TestCase): def test_anydbm_modification(self): self.init_db() - f = anydbm.open(_fname, 'c') + f = dbm.open(_fname, 'c') self._dict['g'] = f[b'g'] = b"indented" self.read_helper(f) f.close() def test_anydbm_read(self): self.init_db() - f = anydbm.open(_fname, 'r') + f = dbm.open(_fname, 'r') self.read_helper(f) f.close() def test_anydbm_keys(self): self.init_db() - f = anydbm.open(_fname, 'r') + f = dbm.open(_fname, 'r') keys = self.keys_helper(f) f.close() def test_anydbm_access(self): self.init_db() - f = anydbm.open(_fname, 'r') + f = dbm.open(_fname, 'r') key = "a".encode("ascii") assert(key in f) assert(f[key] == b"Python:") @@ -100,7 +84,7 @@ class AnyDBMTestCase(unittest.TestCase): self.assertEqual(self._dict[key], f[key.encode("ascii")]) def init_db(self): - f = anydbm.open(_fname, 'n') + f = dbm.open(_fname, 'n') for k in self._dict: f[k.encode("ascii")] = self._dict[k] f.close() @@ -118,10 +102,44 @@ class AnyDBMTestCase(unittest.TestCase): delete_files() +class WhichDBTestCase(unittest.TestCase): + # Actual test methods are added to namespace after class definition. + def __init__(self, *args): + unittest.TestCase.__init__(self, *args) + + def test_whichdb(self): + for module in dbm_iterator(): + # Check whether whichdb correctly guesses module name + # for databases opened with "module" module. + # Try with empty files first + name = module.__name__ + if name == 'dbm.dumb': + continue # whichdb can't support dbm.dumb + test.support.unlink(_fname) + f = module.open(_fname, 'c') + f.close() + self.assertEqual(name, dbm.whichdb(_fname)) + # Now add a key + f = module.open(_fname, 'w') + f[b"1"] = b"1" + # and test that we can find it + self.assertTrue(b"1" in f) + # and read it + self.assertTrue(f[b"1"] == b"1") + f.close() + self.assertEqual(name, dbm.whichdb(_fname)) + + def tearDown(self): + delete_files() + + def setUp(self): + delete_files() + + def test_main(): try: for module in dbm_iterator(): - support.run_unittest(AnyDBMTestCase) + test.support.run_unittest(AnyDBMTestCase, WhichDBTestCase) finally: delete_files() diff --git a/Lib/test/test_bsddb.py b/Lib/test/test_bsddb.py index 3eb291f..a722d8c 100755 --- a/Lib/test/test_bsddb.py +++ b/Lib/test/test_bsddb.py @@ -5,7 +5,7 @@ import os, sys import copy import bsddb -import dbhash # Just so we know it's imported +import dbm.bsd # Just so we know it's imported import unittest from test import support diff --git a/Lib/test/test_dumbdbm.py b/Lib/test/test_dbm_dumb.py index 24c178f..9bdc240 100644 --- a/Lib/test/test_dumbdbm.py +++ b/Lib/test/test_dbm_dumb.py @@ -6,7 +6,7 @@ import io import os import unittest -import dumbdbm +import dbm.dumb as dumbdbm from test import support _fname = support.TESTFN diff --git a/Lib/test/test_gdbm.py b/Lib/test/test_dbm_gnu.py index 42cb136..eddb970 100755 --- a/Lib/test/test_gdbm.py +++ b/Lib/test/test_dbm_gnu.py @@ -1,4 +1,4 @@ -import gdbm +import dbm.gnu as gdbm import unittest import os from test.support import verbose, TESTFN, run_unittest, unlink diff --git a/Lib/test/test_dbm.py b/Lib/test/test_dbm_ndbm.py index 2c6ce99..74d3238 100755 --- a/Lib/test/test_dbm.py +++ b/Lib/test/test_dbm_ndbm.py @@ -2,14 +2,14 @@ from test import support import unittest import os import random -import dbm -from dbm import error +import dbm.ndbm +from dbm.ndbm import error class DbmTestCase(unittest.TestCase): def setUp(self): self.filename = support.TESTFN - self.d = dbm.open(self.filename, 'c') + self.d = dbm.ndbm.open(self.filename, 'c') self.d.close() def tearDown(self): @@ -17,7 +17,7 @@ class DbmTestCase(unittest.TestCase): support.unlink(self.filename + suffix) def test_keys(self): - self.d = dbm.open(self.filename, 'c') + self.d = dbm.ndbm.open(self.filename, 'c') self.assert_(self.d.keys() == []) self.d['a'] = 'b' self.d['12345678910'] = '019237410982340912840198242' @@ -28,9 +28,9 @@ class DbmTestCase(unittest.TestCase): def test_modes(self): for mode in ['r', 'rw', 'w', 'n']: try: - self.d = dbm.open(self.filename, mode) + self.d = dbm.ndbm.open(self.filename, mode) self.d.close() - except dbm.error: + except error: self.fail() def test_main(): diff --git a/Lib/test/test_whichdb.py b/Lib/test/test_whichdb.py deleted file mode 100644 index d908ac5..0000000 --- a/Lib/test/test_whichdb.py +++ /dev/null @@ -1,58 +0,0 @@ -#! /usr/bin/env python -"""Test script for the whichdb module - based on test_anydbm.py -""" - -import os -import test.support -import unittest -import whichdb -import anydbm -import glob -from test.test_anydbm import delete_files, dbm_iterator - -_fname = test.support.TESTFN - -class WhichDBTestCase(unittest.TestCase): - # Actual test methods are added to namespace - # after class definition. - def __init__(self, *args): - unittest.TestCase.__init__(self, *args) - - def test_whichdb(self): - for module in dbm_iterator(): - # Check whether whichdb correctly guesses module name - # for databases opened with "module" module. - # Try with empty files first - name = module.__name__ - if name == 'dumbdbm': - continue # whichdb can't support dumbdbm - test.support.unlink(_fname) - f = module.open(_fname, 'c') - f.close() - self.assertEqual(name, whichdb.whichdb(_fname)) - # Now add a key - f = module.open(_fname, 'w') - f[b"1"] = b"1" - # and test that we can find it - self.assertTrue(b"1" in f) - # and read it - self.assertTrue(f[b"1"] == b"1") - f.close() - self.assertEqual(name, whichdb.whichdb(_fname)) - - def tearDown(self): - delete_files() - - def setUp(self): - delete_files() - - -def test_main(): - try: - test.support.run_unittest(WhichDBTestCase) - finally: - delete_files() - -if __name__ == "__main__": - test_main() diff --git a/Lib/whichdb.py b/Lib/whichdb.py deleted file mode 100644 index ca9c736..0000000 --- a/Lib/whichdb.py +++ /dev/null @@ -1,118 +0,0 @@ -# !/usr/bin/env python -"""Guess which db package to use to open a db file.""" - -import io -import os -import struct -import sys - -try: - import dbm - _dbmerror = dbm.error -except ImportError: - dbm = None - # just some sort of valid exception which might be raised in the - # dbm test - _dbmerror = IOError - -def whichdb(filename): - """Guess which db package to use to open a db file. - - Return values: - - - None if the database file can't be read; - - empty string if the file can be read but can't be recognized - - the module name (e.g. "dbm" or "gdbm") if recognized. - - Importing the given module may still fail, and opening the - database using that module may still fail. - """ - - # Check for dbm first -- this has a .pag and a .dir file - try: - f = io.open(filename + ".pag", "rb") - f.close() - # dbm linked with gdbm on OS/2 doesn't have .dir file - if not (dbm.library == "GNU gdbm" and sys.platform == "os2emx"): - f = io.open(filename + ".dir", "rb") - f.close() - return "dbm" - except IOError: - # some dbm emulations based on Berkeley DB generate a .db file - # some do not, but they should be caught by the dbhash checks - try: - f = io.open(filename + ".db", "rb") - f.close() - # guarantee we can actually open the file using dbm - # kind of overkill, but since we are dealing with emulations - # it seems like a prudent step - if dbm is not None: - d = dbm.open(filename) - d.close() - return "dbm" - except (IOError, _dbmerror): - pass - - # Check for dumbdbm next -- this has a .dir and a .dat file - try: - # First check for presence of files - os.stat(filename + ".dat") - size = os.stat(filename + ".dir").st_size - # dumbdbm files with no keys are empty - if size == 0: - return "dumbdbm" - f = io.open(filename + ".dir", "rb") - try: - if f.read(1) in (b"'", b'"'): - return "dumbdbm" - finally: - f.close() - except (OSError, IOError): - pass - - # See if the file exists, return None if not - try: - f = io.open(filename, "rb") - except IOError: - return None - - # Read the start of the file -- the magic number - s16 = f.read(16) - f.close() - s = s16[0:4] - - # Return "" if not at least 4 bytes - if len(s) != 4: - return "" - - # Convert to 4-byte int in native byte order -- return "" if impossible - try: - (magic,) = struct.unpack("=l", s) - except struct.error: - return "" - - # Check for GNU dbm - if magic == 0x13579ace: - return "gdbm" - - # Check for old Berkeley db hash file format v2 - if magic in (0x00061561, 0x61150600): - return "bsddb185" - - # Later versions of Berkeley db hash file have a 12-byte pad in - # front of the file type - try: - (magic,) = struct.unpack("=l", s16[-4:]) - except struct.error: - return "" - - # Check for BSD hash - if magic in (0x00061561, 0x61150600): - return "dbhash" - - # Unknown - return "" - -if __name__ == "__main__": - for filename in sys.argv[1:]: - print(whichdb(filename) or "UNKNOWN", filename) diff --git a/Misc/PURIFY.README b/Misc/PURIFY.README index 1e5d2ac..c641510 100644 --- a/Misc/PURIFY.README +++ b/Misc/PURIFY.README @@ -57,8 +57,8 @@ following in your .purify file: suppress umr ...; "socketmodule.c" suppress umr ...; time_strftime - suppress umr ...; "dbmmodule.c" - suppress umr ...; "gdbmmodule.c" + suppress umr ...; "_dbmmodule.c" + suppress umr ...; "_gdbmmodule.c" suppress umr ...; "grpmodule.c" suppress umr ...; "nismodule.c" suppress umr ...; "pwdmodule.c" diff --git a/Misc/cheatsheet b/Misc/cheatsheet index c383e4a..c959de5 100644 --- a/Misc/cheatsheet +++ b/Misc/cheatsheet @@ -1795,8 +1795,8 @@ List of modules and packages in base distribution Standard library modules Operation Result aifc Stuff to parse AIFF-C and AIFF files. -anydbm Generic interface to all dbm clones. (dbhash, gdbm, - dbm,dumbdbm) +dbm Generic interface to all dbm clones. (dbm.bsd, dbm.gnu, + dbm.ndbm, dbm.dumb) asynchat Support for 'chat' style protocols asyncore Asynchronous File I/O (in select style) atexit Register functions to be called at exit of Python interpreter. @@ -1822,21 +1822,16 @@ ConfigParser Configuration file parser (much like windows .ini files) copy Generic shallow and deep copying operations. copy_reg Helper to provide extensibility for pickle/cPickle. csv Read and write files with comma separated values. -dbhash (g)dbm-compatible interface to bsdhash.hashopen. dircache Sorted list of files in a dir, using a cache. -[DEL:dircmp:DEL] [DEL:Defines a class to build directory diff tools on.:DEL] difflib Tool for creating delta between sequences. dis Bytecode disassembler. distutils Package installation system. doctest Tool for running and verifying tests inside doc strings. dospath Common operations on DOS pathnames. -dumbdbm A dumb and slow but simple dbm clone. -[DEL:dump:DEL] [DEL:Print python code that reconstructs a variable.:DEL] email Comprehensive support for internet email. filecmp File comparison. fileinput Helper class to quickly write a loop over all standard input files. -[DEL:find:DEL] [DEL:Find files directory hierarchy matching a pattern.:DEL] fnmatch Filename matching with shell patterns. formatter A test formatter. fpformat General floating point formatting functions. @@ -1847,7 +1842,6 @@ getopt Standard command line processing. See also ftp:// www.pauahtun.org/pub/getargspy.zip getpass Utilities to get a password and/or the current user name. glob filename globbing. -[DEL:grep:DEL] [DEL:'grep' utilities.:DEL] gzip Read & write gzipped files. heapq Priority queue implemented using lists organized as heaps. HMAC Keyed-Hashing for Message Authentication -- RFC 2104. @@ -1882,8 +1876,6 @@ ntpath Common operations on DOS pathnames. nturl2path Mac specific module for conversion between pathnames and URLs. optparse A comprehensive tool for processing command line options. os Either mac, dos or posix depending system. -[DEL:packmail: [DEL:Create a self-unpacking shell archive.:DEL] -DEL] pdb A Python debugger. pickle Pickling (save and restore) of Python objects (a faster Cimplementation exists in built-in module: cPickle). @@ -1929,7 +1921,7 @@ StringIO File-like objects that read/write a string buffer (a fasterC sunau Stuff to parse Sun and NeXT audio files. sunaudio Interpret sun audio headers. symbol Non-terminal symbols of Python grammar (from "graminit.h"). -tabnanny,/font> Check Python source for ambiguous indentation. +tabnanny Check Python source for ambiguous indentation. tarfile Facility for reading and writing to the *nix tarfile format. telnetlib TELNET client class. Based on RFC 854. tempfile Temporary file name allocation. @@ -1950,15 +1942,11 @@ user Hook to allow user-specified customization code to run. UserDict A wrapper to allow subclassing of built-in dict class. UserList A wrapper to allow subclassing of built-in list class. UserString A wrapper to allow subclassing of built-in string class. -[DEL:util:DEL] [DEL:some useful functions that don't fit elsewhere !!:DEL] uu UUencode/UUdecode. unittest Utilities for implementing unit testing. wave Stuff to parse WAVE files. weakref Tools for creating and managing weakly referenced objects. webbrowser Platform independent URL launcher. -[DEL:whatsound: [DEL:Several routines that help recognizing sound files.:DEL] -DEL] -whichdb Guess which db package to use to open a db file. xdrlib Implements (a subset of) Sun XDR (eXternal Data Representation) xmllib A parser for XML, using the derived class as static DTD. @@ -1966,7 +1954,6 @@ xml.dom Classes for processing XML using the Document Object Model. xml.sax Classes for processing XML using the SAX API. xmlrpclib Support for remote procedure calls using XML. zipfile Read & write PK zipped files. -[DEL:zmod:DEL] [DEL:Demonstration of abstruse mathematical concepts.:DEL] @@ -1993,7 +1980,7 @@ zipfile Read & write PK zipped files. * Unix/Posix * - dbm Interface to Unix ndbm database library + dbm Interface to Unix dbm databases grp Interface to Unix group database posix OS functionality standardized by C and POSIX standards posixpath POSIX pathname functions diff --git a/Modules/Setup.dist b/Modules/Setup.dist index 6c201c9..88c85b5 100644 --- a/Modules/Setup.dist +++ b/Modules/Setup.dist @@ -294,8 +294,8 @@ _symtable symtablemodule.c # Modules that provide persistent dictionary-like semantics. You will # probably want to arrange for at least one of them to be available on # your machine, though none are defined by default because of library -# dependencies. The Python module anydbm.py provides an -# implementation independent wrapper for these; dumbdbm.py provides +# dependencies. The Python module dbm/__init__.py provides an +# implementation independent wrapper for these; dbm/dumb.py provides # similar functionality (but slower of course) implemented in Python. # The standard Unix dbm module has been moved to Setup.config so that @@ -305,13 +305,13 @@ _symtable symtablemodule.c # # First, look at Setup.config; configure may have set this for you. -#dbm dbmmodule.c # dbm(3) may require -lndbm or similar +#_dbm _dbmmodule.c # dbm(3) may require -lndbm or similar # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm: # # First, look at Setup.config; configure may have set this for you. -#gdbm gdbmmodule.c -I/usr/local/include -L/usr/local/lib -lgdbm +#_gdbm _gdbmmodule.c -I/usr/local/include -L/usr/local/lib -lgdbm # Sleepycat Berkeley DB interface. diff --git a/Modules/dbmmodule.c b/Modules/_dbmmodule.c index 875f0e7..1a49e24 100644 --- a/Modules/dbmmodule.c +++ b/Modules/_dbmmodule.c @@ -332,7 +332,7 @@ dbm_getattr(dbmobject *dp, char *name) static PyTypeObject Dbmtype = { PyVarObject_HEAD_INIT(NULL, 0) - "dbm.dbm", + "_dbm.dbm", sizeof(dbmobject), 0, (destructor)dbm_dealloc, /*tp_dealloc*/ @@ -391,17 +391,17 @@ static PyMethodDef dbmmodule_methods[] = { }; PyMODINIT_FUNC -initdbm(void) { +init_dbm(void) { PyObject *m, *d, *s; if (PyType_Ready(&Dbmtype) < 0) return; - m = Py_InitModule("dbm", dbmmodule_methods); + m = Py_InitModule("_dbm", dbmmodule_methods); if (m == NULL) return; d = PyModule_GetDict(m); if (DbmError == NULL) - DbmError = PyErr_NewException("dbm.error", NULL, NULL); + DbmError = PyErr_NewException("_dbm.error", NULL, NULL); s = PyUnicode_FromString(which_dbm); if (s != NULL) { PyDict_SetItemString(d, "library", s); diff --git a/Modules/gdbmmodule.c b/Modules/_gdbmmodule.c index a8abbd3..4404d2f 100644 --- a/Modules/gdbmmodule.c +++ b/Modules/_gdbmmodule.c @@ -389,7 +389,7 @@ dbm_getattr(dbmobject *dp, char *name) static PyTypeObject Dbmtype = { PyVarObject_HEAD_INIT(0, 0) - "gdbm.gdbm", + "_gdbm.gdbm", sizeof(dbmobject), 0, (destructor)dbm_dealloc, /*tp_dealloc*/ @@ -512,18 +512,18 @@ static PyMethodDef dbmmodule_methods[] = { }; PyMODINIT_FUNC -initgdbm(void) { +init_gdbm(void) { PyObject *m, *d, *s; if (PyType_Ready(&Dbmtype) < 0) return; - m = Py_InitModule4("gdbm", dbmmodule_methods, + m = Py_InitModule4("_gdbm", dbmmodule_methods, gdbmmodule__doc__, (PyObject *)NULL, PYTHON_API_VERSION); if (m == NULL) return; d = PyModule_GetDict(m); - DbmError = PyErr_NewException("gdbm.error", NULL, NULL); + DbmError = PyErr_NewException("_gdbm.error", NULL, NULL); if (DbmError != NULL) { PyDict_SetItemString(d, "error", DbmError); s = PyUnicode_FromString(dbmmodule_open_flags); diff --git a/Modules/_threadmodule.c b/Modules/_threadmodule.c index 971ff56..5b8fc98 100644 --- a/Modules/_threadmodule.c +++ b/Modules/_threadmodule.c @@ -127,7 +127,7 @@ lock_getattr(lockobject *self, char *name) static PyTypeObject Locktype = { PyVarObject_HEAD_INIT(&PyType_Type, 0) - "thread.lock", /*tp_name*/ + "_thread.lock", /*tp_name*/ sizeof(lockobject), /*tp_size*/ 0, /*tp_itemsize*/ /* methods */ @@ -336,7 +336,7 @@ static PyObject *local_getattro(localobject *, PyObject *); static PyTypeObject localtype = { PyVarObject_HEAD_INIT(NULL, 0) - /* tp_name */ "thread._local", + /* tp_name */ "_thread._local", /* tp_basicsize */ sizeof(localobject), /* tp_itemsize */ 0, /* tp_dealloc */ (destructor)local_dealloc, diff --git a/PC/os2emx/Makefile b/PC/os2emx/Makefile index 5f4cab8..a2947a7 100644 --- a/PC/os2emx/Makefile +++ b/PC/os2emx/Makefile @@ -464,7 +464,7 @@ ifeq ($(HAVE_NCURSES),yes) HARDEXTMODULES+= _curses_ endif ifeq ($(HAVE_GDBM),yes) - HARDEXTMODULES+= gdbm dbm + HARDEXTMODULES+= _gdbm _dbm endif ifeq ($(HAVE_BZ2),yes) HARDEXTMODULES+= bz2 @@ -626,10 +626,10 @@ _curses_panel$(MODULE.EXT): $(OUT)_curses_panel$O $(OUT)_curses_panel_m.def $(PY _curses_$(MODULE.EXT): _curses_panel$(MODULE.EXT) cp $^ $@ -dbm$(MODULE.EXT): $(OUT)dbmmodule$O $(OUT)dbm_m.def $(PYTHON.IMPLIB) +_dbm$(MODULE.EXT): $(OUT)_dbmmodule$O $(OUT)dbm_m.def $(PYTHON.IMPLIB) $(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) -lgdbm -gdbm$(MODULE.EXT): $(OUT)gdbmmodule$O $(OUT)gdbm_m.def $(PYTHON.IMPLIB) +_gdbm$(MODULE.EXT): $(OUT)_gdbmmodule$O $(OUT)gdbm_m.def $(PYTHON.IMPLIB) $(LD) $(LDFLAGS.DLL) -o $@ $(^^) $(L^) $(LIBS) -lgdbm diff --git a/PC/os2vacpp/makefile b/PC/os2vacpp/makefile index 50119a0..55bb783 100644 --- a/PC/os2vacpp/makefile +++ b/PC/os2vacpp/makefile @@ -494,7 +494,7 @@ cursesmodule.obj: $(PY_INCLUDE)\abstract.h $(PY_INCLUDE)\ceval.h \ $(PY_INCLUDE)\stringobject.h $(PY_INCLUDE)\sysmodule.h $(PY_INCLUDE)\traceback.h \ $(PY_INCLUDE)\tupleobject.h -dbmmodule.obj: $(PY_INCLUDE)\abstract.h $(PY_INCLUDE)\ceval.h $(PY_INCLUDE)\classobject.h \ +_dbmmodule.obj: $(PY_INCLUDE)\abstract.h $(PY_INCLUDE)\ceval.h $(PY_INCLUDE)\classobject.h \ $(PY_INCLUDE)\cobject.h $(PY_INCLUDE)\complexobject.h pyconfig.h \ $(PY_INCLUDE)\dictobject.h $(PY_INCLUDE)\fileobject.h $(PY_INCLUDE)\floatobject.h \ $(PY_INCLUDE)\funcobject.h $(PY_INCLUDE)\import.h $(PY_INCLUDE)\intobject.h \ @@ -576,7 +576,7 @@ fpetestmodule.obj: $(PY_INCLUDE)\abstract.h $(PY_INCLUDE)\ceval.h \ $(PY_INCLUDE)\stringobject.h $(PY_INCLUDE)\sysmodule.h $(PY_INCLUDE)\traceback.h \ $(PY_INCLUDE)\tupleobject.h -gdbmmodule.obj: $(PY_INCLUDE)\abstract.h $(PY_INCLUDE)\ceval.h $(PY_INCLUDE)\classobject.h \ +_gdbmmodule.obj: $(PY_INCLUDE)\abstract.h $(PY_INCLUDE)\ceval.h $(PY_INCLUDE)\classobject.h \ $(PY_INCLUDE)\cobject.h $(PY_INCLUDE)\complexobject.h pyconfig.h \ $(PY_INCLUDE)\dictobject.h $(PY_INCLUDE)\fileobject.h $(PY_INCLUDE)\floatobject.h \ $(PY_INCLUDE)\funcobject.h $(PY_INCLUDE)\import.h $(PY_INCLUDE)\intobject.h \ diff --git a/PC/os2vacpp/makefile.omk b/PC/os2vacpp/makefile.omk index a925efb..7083c78 100644 --- a/PC/os2vacpp/makefile.omk +++ b/PC/os2vacpp/makefile.omk @@ -171,8 +171,8 @@ MODULES = \ # audioop.c -- Various Compute Operations on Audio Samples # Database: - # dbmmodule.c -- Wrapper of DBM Database API (Generic Flavor) - # gdbmmodule.c -- Wrapper of DBM Database API (GNU Flavor) + # _dbmmodule.c -- Wrapper of DBM Database API (Generic Flavor) + # _gdbmmodule.c -- Wrapper of DBM Database API (GNU Flavor) # Cryptography: # cryptmodule.c -- Simple Wrapper for crypt() Function @@ -410,7 +410,7 @@ cursesmodule.obj: abstract.h ceval.h classobject.h cobject.h \ pystate.h python.h pythonrun.h rangeobject.h sliceobject.h \ stringobject.h sysmodule.h traceback.h tupleobject.h -dbmmodule.obj: abstract.h ceval.h classobject.h cobject.h complexobject.h \ +_dbmmodule.obj: abstract.h ceval.h classobject.h cobject.h complexobject.h \ pyconfig.h dictobject.h fileobject.h floatobject.h funcobject.h \ import.h intobject.h intrcheck.h listobject.h longobject.h \ methodobject.h modsupport.h moduleobject.h mymalloc.h myproto.h \ @@ -458,7 +458,7 @@ fpetestmodule.obj: abstract.h ceval.h classobject.h cobject.h \ pystate.h python.h pythonrun.h rangeobject.h sliceobject.h \ stringobject.h sysmodule.h traceback.h tupleobject.h -gdbmmodule.obj: abstract.h ceval.h classobject.h cobject.h complexobject.h \ +_gdbmmodule.obj: abstract.h ceval.h classobject.h cobject.h complexobject.h \ pyconfig.h dictobject.h fileobject.h floatobject.h funcobject.h \ import.h intobject.h intrcheck.h listobject.h longobject.h \ methodobject.h modsupport.h moduleobject.h mymalloc.h myproto.h \ diff --git a/Tools/scripts/db2pickle.py b/Tools/scripts/db2pickle.py index 795011b..0c9b6bf 100644 --- a/Tools/scripts/db2pickle.py +++ b/Tools/scripts/db2pickle.py @@ -6,7 +6,7 @@ Synopsis: %(prog)s [-h|-g|-b|-r|-a] dbfile [ picklefile ] Convert the database file given on the command line to a pickle representation. The optional flags indicate the type of the database: - -a - open using anydbm + -a - open using dbm (any supported format) -b - open as bsddb btree file -d - open as dbm file -g - open as gdbm file @@ -25,15 +25,15 @@ try: except ImportError: bsddb = None try: - import dbm + import dbm.ndbm as dbm except ImportError: dbm = None try: - import gdbm + import dbm.gnu as gdbm except ImportError: gdbm = None try: - import anydbm + import dbm as anydbm except ImportError: anydbm = None import sys @@ -94,19 +94,19 @@ def main(args): try: dbopen = anydbm.open except AttributeError: - sys.stderr.write("anydbm module unavailable.\n") + sys.stderr.write("dbm module unavailable.\n") return 1 elif opt in ("-g", "--gdbm"): try: dbopen = gdbm.open except AttributeError: - sys.stderr.write("gdbm module unavailable.\n") + sys.stderr.write("dbm.gnu module unavailable.\n") return 1 elif opt in ("-d", "--dbm"): try: dbopen = dbm.open except AttributeError: - sys.stderr.write("dbm module unavailable.\n") + sys.stderr.write("dbm.ndbm module unavailable.\n") return 1 if dbopen is None: if bsddb is None: diff --git a/Tools/scripts/pickle2db.py b/Tools/scripts/pickle2db.py index c66f5e9..357e628 100644 --- a/Tools/scripts/pickle2db.py +++ b/Tools/scripts/pickle2db.py @@ -7,10 +7,10 @@ Read the given picklefile as a series of key/value pairs and write to a new database. If the database already exists, any contents are deleted. The optional flags indicate the type of the output database: - -a - open using anydbm + -a - open using dbm (open any supported format) -b - open as bsddb btree file - -d - open as dbm file - -g - open as gdbm file + -d - open as dbm.ndbm file + -g - open as dbm.gnu file -h - open as bsddb hash file -r - open as bsddb recno file @@ -30,15 +30,15 @@ try: except ImportError: bsddb = None try: - import dbm + import dbm.ndbm as dbm except ImportError: dbm = None try: - import gdbm + import dbm.gnu as gdbm except ImportError: gdbm = None try: - import anydbm + import dbm as anydbm except ImportError: anydbm = None import sys @@ -99,19 +99,19 @@ def main(args): try: dbopen = anydbm.open except AttributeError: - sys.stderr.write("anydbm module unavailable.\n") + sys.stderr.write("dbm module unavailable.\n") return 1 elif opt in ("-g", "--gdbm"): try: dbopen = gdbm.open except AttributeError: - sys.stderr.write("gdbm module unavailable.\n") + sys.stderr.write("dbm.gnu module unavailable.\n") return 1 elif opt in ("-d", "--dbm"): try: dbopen = dbm.open except AttributeError: - sys.stderr.write("dbm module unavailable.\n") + sys.stderr.write("dbm.ndbm module unavailable.\n") return 1 if dbopen is None: if bsddb is None: @@ -637,8 +637,8 @@ class PyBuildExt(build_ext): # Modules that provide persistent dictionary-like semantics. You will # probably want to arrange for at least one of them to be available on # your machine, though none are defined by default because of library - # dependencies. The Python module anydbm.py provides an - # implementation independent wrapper for these; dumbdbm.py provides + # dependencies. The Python module dbm/__init__.py provides an + # implementation independent wrapper for these; dbm/dumb.py provides # similar functionality (but slower of course) implemented in Python. # Sleepycat^WOracle Berkeley DB interface. @@ -902,16 +902,16 @@ class PyBuildExt(build_ext): ndbm_libs = ['ndbm'] else: ndbm_libs = [] - exts.append( Extension('dbm', ['dbmmodule.c'], + exts.append( Extension('_dbm', ['_dbmmodule.c'], define_macros=[('HAVE_NDBM_H',None)], libraries = ndbm_libs ) ) elif (self.compiler.find_library_file(lib_dirs, 'gdbm') and find_file("gdbm/ndbm.h", inc_dirs, []) is not None): - exts.append( Extension('dbm', ['dbmmodule.c'], + exts.append( Extension('_dbm', ['_dbmmodule.c'], define_macros=[('HAVE_GDBM_NDBM_H',None)], libraries = ['gdbm'] ) ) elif db_incs is not None: - exts.append( Extension('dbm', ['dbmmodule.c'], + exts.append( Extension('_dbm', ['_dbmmodule.c'], library_dirs=dblib_dir, runtime_library_dirs=dblib_dir, include_dirs=db_incs, @@ -919,14 +919,14 @@ class PyBuildExt(build_ext): ('DB_DBM_HSEARCH',None)], libraries=dblibs)) else: - missing.append('dbm') + missing.append('_dbm') # Anthony Baxter's gdbm module. GNU dbm(3) will require -lgdbm: if (self.compiler.find_library_file(lib_dirs, 'gdbm')): - exts.append( Extension('gdbm', ['gdbmmodule.c'], + exts.append( Extension('_gdbm', ['_gdbmmodule.c'], libraries = ['gdbm'] ) ) else: - missing.append('gdbm') + missing.append('_gdbm') # Unix-only modules if platform not in ['mac', 'win32']: |