~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/util/configobj/docs/configobj.txt

Updated ConfigObj to 4.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
7
7
----------------------------------------
8
8
 
9
9
:Authors: Michael Foord, Nicola Larosa
10
 
:Version: ConfigObj 4.0.0
11
 
:Date: 2005/10/17
 
10
:Version: ConfigObj 4.2.0
 
11
:Date: 2006/02/16
12
12
:Homepage: `ConfigObj Homepage`_
13
13
:Sourceforge: Sourceforge_
14
14
:License: `BSD License`_
33
33
straightforward programmer's interface and a simple syntax for config files.
34
34
It has lots of other features though :
35
35
 
 
36
.. sidebar:: ConfigObj in Bazaar
 
37
 
 
38
    **ConfigObj** is now used as the config file parser for `Bazaar <http://bazaar-ng.org>`_.
 
39
    
 
40
    Bazaar is *the* Python  distributed {acro;VCS;Version Control System}. 
 
41
    ConfigObj is used to read ``bazaar.conf`` and ``branches.conf``.
 
42
    
 
43
    Other projects that use **ConfigObj** include :
 
44
    
 
45
    * `Planet Plus <http://planetplus.python-hosting.com/>`_
 
46
    
 
47
        A new web application version of `Planet <http://www.planetplanet.org/>`_, 
 
48
        the web aggregator.
 
49
        
 
50
    * `NeuroImaging in Python <http://projects.scipy.org/neuroimaging/ni/wiki>`_
 
51
    
 
52
        BrainSTAT is a project with the ultimate goal to produce a
 
53
        platform-independent python environment for the analysis of brain
 
54
        imaging data.
 
55
        
 
56
    * `Gruik <http://www.tracos.org/gruik/wiki>`_
 
57
    
 
58
        Gruik is a free software network packet sniffer.
 
59
 
36
60
* Nested sections (subsections), to any level
37
61
* List values
38
62
* Multiple line values
39
63
* String interpolation (substitution)
40
64
* Integrated with a powerful validation system
41
65
 
42
 
    * including automatic type checking/conversion
43
 
    * repeated sections
44
 
    * and allowing default values
 
66
    - including automatic type checking/conversion
 
67
    - repeated sections
 
68
    - and allowing default values
45
69
 
46
70
* All comments in the file are preserved
47
71
* The order of keys/sections is preserved
48
72
* No external dependencies
49
 
 
50
 
ConfigObj 4 is a complete rewrite of ConfigObj. A great deal has been
51
 
simplified and improved [#]_ since ConfigObj 3. If you have used ConfigObj
52
 
before then you need to read the section on `backwards compatibility`_.
53
 
 
54
 
ConfigObj now has a barrage [#]_ of doctests built into it, testing almost every
55
 
feature. Run ``python configobj.py -v`` to see them in action. Despite the tests,
56
 
ConfigObj 4 is actually smaller than version 3 and has no external dependencies.
 
73
* Full unicode support.
 
74
 
 
75
ConfigObj 4 is a complete rewrite of ConfigObj. ConfigObj now has a barrage [#]_
 
76
of doctests built into it, testing almost every feature. Run ``python configobj.py -v``
 
77
to see them in action. Despite the tests, ConfigObj 4 is smaller than version 3
 
78
and has no external dependencies.
57
79
 
58
80
For support and bug reports please use the ConfigObj `Mailing List`_.
59
81
 
60
82
.. hint::
61
83
 
62
 
    There is an article on using `ConfigObj for Data Persistence`_.
 
84
    ConfigObj provides a convenient API for storing all sorts of data, not just
 
85
    config files. There is an article on using `ConfigObj for Data Persistence`_.
63
86
    
64
87
    The code from that article is available as ConfigPersist.py_.
65
88
 
66
89
.. _ConfigObj for Data Persistence: http://www.voidspace.org.uk/python/articles/configobj_for_data_persistence.shtml
67
90
.. _ConfigPersist.py: http://www.voidspace.org.uk/python/configpersist.html
68
91
 
 
92
 
69
93
Downloading
70
94
===========
71
95
 
72
 
The current version is **4.0.0**, dated 17th October 2005. ConfigObj 4 is
73
 
now stable. We may still expect to pick up a few bugs along the way though [#]_.
 
96
The current version is **4.2.0**, dated 16th February 2006. ConfigObj 4 is
 
97
now stable. We still expect to pick up a few bugs along the way though [#]_.
74
98
{sm;:-)}
75
99
 
76
100
You can get ConfigObj in the following ways :
112
136
Projects`_.
113
137
 
114
138
.. _configobj.py: http://www.voidspace.org.uk/cgi-bin/voidspace/downman.py?file=configobj.py
115
 
.. _configobj.zip: http://www.voidspace.org.uk/cgi-bin/voidspace/downman.py?file=configobj-4.0.0.zip
 
139
.. _configobj.zip: http://www.voidspace.org.uk/cgi-bin/voidspace/downman.py?file=configobj-4.2.0.zip
116
140
.. _validate.py: http://www.voidspace.org.uk/cgi-bin/voidspace/downman.py?file=validate.py
117
141
.. _API Docs: http://www.voidspace.org.uk/python/configobj-api/
118
142
.. _this document:
123
147
.. _pythonutils: http://www.voidspace.org.uk/python/pythonutils.html
124
148
.. _Voidspace Python Projects: http://www.voidspace.org.uk/python
125
149
 
 
150
 
126
151
Getting Started
127
152
===============
128
153
 
267
292
    # The 'final_comment'
268
293
    # Which also may be several lines
269
294
 
 
295
 
270
296
ConfigObj specifications
271
297
========================
272
298
 
291
317
  the options_ ``file_error`` and ``create_empty``. The filename will be
292
318
  preserved as the ``filename`` attribute. This can be changed at any time.
293
319
 
294
 
* A list of lines. Any trailing ``\n`` will be removed from the lines. The
 
320
* A list of lines. Any trailing newlines will be removed from the lines. The
295
321
  ``filename`` attribute of your ConfigObj will be ``None``.
296
322
 
297
 
* A ``StringIO`` instance or file object, or any object with ``seek`` and
298
 
  ``read`` methods. The object you pass in will be preserved as the
299
 
  ``filename`` attribute of your ConfigObj. If it has a ``write`` method [#]_
300
 
  then you can use the ConfigObj ``write`` method. Note that a file object
301
 
  passed in won't have its ``close`` method called by ConfigObj.
 
323
* A ``StringIO`` instance or file object, or any object with a ``read`` method.
 
324
  The ``filename`` attribute of your ConfigObj will be ``None`` [#]_.
302
325
 
303
326
* A dictionary. You can initialise a ConfigObj from a dictionary [#]_. The
304
327
  ``filename`` attribute of your ConfigObj will be ``None``. All keys must be
329
352
 
330
353
    If ``True`` (the default) then list values are possible. If ``False``, the
331
354
    values are not parsed for lists.
 
355
        
 
356
        If ``list_values = False`` then single line values are not quoted or
 
357
        unqouted when reading and writing.
332
358
 
333
 
    Altering this value after initial parsing has no effect.
 
359
    Changing this value affects whether single line values will be quoted or 
 
360
    not when writing.
334
361
 
335
362
* 'create_empty': ``False``
336
363
 
402
429
    If this option *is* specified, the option value is used in the output
403
430
    config, overriding the type of indentation in the input config (if any).
404
431
 
 
432
* 'encoding': ``None``
 
433
 
 
434
    By default **ConfigObj** does not decode the file/strings you pass it into
 
435
    Unicode [#]_. If you want your config file as Unicode (keys and members)
 
436
    you need to provide an encoding to decode the file with. This encoding will
 
437
    also be used to encode the config file when writing.
 
438
    
 
439
    You can change the encoding attribute at any time.
 
440
    
 
441
    Any characters in your strings that can't be encoded with the specified
 
442
    encoding will raise a ``UnicodeEncodeError``.
 
443
    
 
444
    .. note::
 
445
    
 
446
        ``UTF16`` encoded files will automatically be detected and decoded,
 
447
        even if ``encoding`` is ``None``.
 
448
        
 
449
        This is because it is a 16-bit encoding, and ConfigObj will mangle it
 
450
        (split characters on byte boundaries) if it parses it without decoding.
 
451
 
 
452
* 'default_encoding': ``None``
 
453
 
 
454
    When using the ``write`` method, **ConfigObj** uses the ``encoding``
 
455
    attribute to encode the Unicode strings. If any members (or keys) have
 
456
    been set as byte strings instead of Unicode, these must first be decoded
 
457
    to Unicode before outputting in the specified encoding.
 
458
 
 
459
    ``default_encoding``, if specified, is the encoding used to decode byte
 
460
    strings in the **ConfigObj** before writing. If this is ``None``, then
 
461
    the Python default encoding (``sys.defaultencoding`` - usually ascii) is
 
462
    used.
 
463
    
 
464
    For most Western European users, a value of ``latin-1`` is sensible.
 
465
    
 
466
    ``default_encoding`` is *only* used if an ``encoding`` is specified.
 
467
    
 
468
    Any characters in byte-strings that can't be decoded using the
 
469
    ``default_encoding`` will raise a ``UnicodeDecodeError``.
 
470
 
 
471
 
405
472
Methods
406
473
-------
407
474
 
409
476
subclass of ``dict``, the builtin dictionary type. This means it also has
410
477
**all** the normal dictionary methods.
411
478
 
412
 
In addition, the *encode*, *decode*, *walk*, and *dict* methods of section may
413
 
be useful. The sections and subsections are also instances of ``Section``. Read
414
 
about Sections_ for details of all the methods.
 
479
In addition, the following `Section Methods`_ may be useful :
 
480
 
 
481
* *encode*
 
482
* *decode*
 
483
* *walk*
 
484
* *merge*
 
485
* *dict* 
 
486
* *as_bool*
 
487
* *as_float*
 
488
* *as_int*
 
489
 
 
490
Read about Sections_ for details of all the methods.
 
491
 
 
492
.. hint::
 
493
 
 
494
    The *merge* method of sections is a recursive update.
 
495
    
 
496
    You can use this to merge sections, or even whole ConfigObjs, into each
 
497
    other.
 
498
    
 
499
    You would typically use this to create a default ConfigObj and then merge
 
500
    in user settings. This way users only need to specify values that are
 
501
    different from the default.
 
502
    
415
503
 
416
504
The public methods available on ConfigObj are :
417
505
 
421
509
write
422
510
~~~~~
423
511
 
424
 
This method takes no arguments [#]_. It writes the current ConfigObj. What that
425
 
means depends on the ``filename`` attribute of the ConfigObj.
426
 
 
427
 
filename
428
 
    ConfigObj will write the configuration to file.
 
512
::
 
513
 
 
514
    write(file_object=None)
 
515
 
 
516
This method writes the current ConfigObj and takes a single, optional argument
 
517
[#]_.
 
518
 
 
519
If you pass in a file like object to the ``write`` method, the config file will
 
520
be written to this. (The only method of this object that is used is its
 
521
``write`` method, so a ``StringIO`` instance, or any other file like object
 
522
will work.)
 
523
 
 
524
Otherwise, the behaviour of this method depends on the ``filename`` attribute
 
525
of the ConfigObj.
 
526
 
 
527
``filename``
 
528
    ConfigObj will write the configuration to the file specified.
429
529
 
430
530
``None``
431
531
    ``write`` returns a list of lines. (Not ``'\n'`` terminated)
432
532
 
433
 
``StringIO``
434
 
    If ``filename`` is an object with a seek attribute, then the config file is
435
 
    written to that object.
436
 
 
437
533
First the 'initial_comment' is written, then the config file, followed by the
438
534
'final_comment'. Comment lines and inline comments are written with each
439
535
key/value.
441
537
validate
442
538
~~~~~~~~
443
539
 
 
540
::
 
541
 
 
542
    validate(validator, preserve_errors=False)
 
543
 
444
544
.. raw:: html
445
545
 
446
546
    {+coloring}
458
558
 
459
559
    {-coloring}
460
560
 
 
561
The validate method uses the `validate 
 
562
<http://www.voidspace.org.uk/python/validate.html>`__ module to do the
 
563
validation.
 
564
    
461
565
This method validates the ConfigObj against the configspec. By doing type
462
566
conversion as well, it can abstract away the config file altogether and present
463
567
the config *data* to your application (in the types it expects it to be).
483
587
    
484
588
    See `ConfigObj for Data Persistence`_.
485
589
 
 
590
 
486
591
Return Value
487
592
############
488
593
 
489
 
The validate method either returns ``True`` (everything passed) or a dictionary 
490
 
of ``True``/``False`` representing pass/fail. The dictionary follows the 
491
 
structure of the ConfigObj
 
594
By default, the validate method either returns ``True`` (everything passed) 
 
595
or a dictionary of ``True``/``False`` representing pass/fail. The dictionary 
 
596
follows the structure of the ConfigObj.
492
597
 
493
598
If a whole section passes then it is replaced with the value ``True``. If a 
494
599
whole section fails, then it is replaced with the value ``False``.
496
601
If a value is missing, and there is no default in the check, then the check 
497
602
automatically fails.
498
603
 
 
604
The ``validate`` method takes an optional keyword argument ``preserve_errors``.
 
605
If you set this to ``True``, instead of getting ``False`` for failed checks you
 
606
get the actual error object from the **validate** module. This usually contains
 
607
useful information about why the check failed.
 
608
 
 
609
See the `flatten_errors`_ function for how to turn your results dictionary into
 
610
a useful list of error messages.
 
611
 
 
612
Even if ``preserve_errors`` is ``True``, missing keys or sections will still be
 
613
represented by a ``False`` in the results dictionary.
 
614
 
 
615
 
499
616
Mentioning Default Values
500
617
#########################
501
618
 
536
653
    ``None``. This is because setting a value to a non-string raises an error
537
654
    if stringify is unset.
538
655
 
 
656
The default value can be a list. See `List Values`_ for the way to do this.
 
657
 
 
658
Writing invalid default values is a *guaranteed* way of confusing your users.
 
659
Default values **must** pass the check.
 
660
 
539
661
Mentioning Repeated Sections
540
662
############################
541
663
 
554
676
 
555
677
See `Repeated Sections`_ for examples.
556
678
 
 
679
 
557
680
Mentioning SimpleVal
558
681
####################
559
682
 
575
698
 
576
699
    {-coloring}
577
700
 
 
701
    
578
702
Attributes
579
703
----------
580
704
 
586
710
* BOM
587
711
* initial_comment
588
712
* final_comment
 
713
* list_values
 
714
* encoding
 
715
* default_encoding
589
716
 
590
717
.. note::
591
718
 
598
725
* raise_errors
599
726
* create_empty
600
727
* file_error
601
 
* list_values
602
728
 
603
729
interpolate
604
730
~~~~~~~~~~~
623
749
~~~
624
750
 
625
751
If the initial config file *started* with the UTF8 Unicode signature (known
626
 
slightly incorrectly as the {acro;BOM;Byte Order Mark}), then this value will
627
 
be set to the UTF8 BOM. Otherwise it is ``None``.
628
 
 
629
 
If it is set, then it is  written out by the ``write`` method.
 
752
slightly incorrectly as the {acro;BOM;Byte Order Mark}), or the UTF16 BOM, then
 
753
this attribute is set to ``True``. Otherwise it is ``False``.
 
754
 
 
755
If it is set to ``True`` when ``write`` is called then, if ``encoding`` is set
 
756
to ``None`` *or* to ``utf_8`` (and variants) a UTF BOM will be written.
 
757
 
 
758
For UTF16 encodings, a BOM is *always* written.
630
759
 
631
760
initial_comment
632
761
~~~~~~~~~~~~~~~
649
778
The ``write`` method puts these lines after it finishes writing out the
650
779
members.
651
780
 
 
781
list_values
 
782
~~~~~~~~~~~
 
783
 
 
784
This attribute is ``True`` or ``False``. If set to ``False`` then values are
 
785
not parsed for list values. In addition single line values are not unquoted.
 
786
 
 
787
This allows you to do your own parsing of values. It exists primarily to
 
788
support the reading of the configspec_ - but has other use cases.
 
789
 
 
790
For example you could use the ``LineParser`` from the
 
791
`listquote module <http://www.voidspace.org.uk/python/listquote.html#lineparser>`_ 
 
792
to read values for nested lists.
 
793
 
 
794
Single line values aren't quoted when writing - but multiline values are
 
795
handled as normal.
 
796
 
 
797
.. caution::
 
798
 
 
799
    Because values aren't quoted, leading or trailing whitespace can be
 
800
        lost.
 
801
 
 
802
    This behaviour was changed in version 4.0.1.
 
803
        
 
804
        Prior to this, single line values might have been quoted; even with
 
805
        ``list_values=False``. This means that files written by **ConfigObj**
 
806
        *could* now be incompatible - and need the quotes removing by hand.
 
807
 
 
808
encoding
 
809
~~~~~~~~
 
810
 
 
811
This is the encoding used to encode the output, when you call ``write``. It
 
812
must be a valid encoding `recognised by Python <http://docs.python.org/lib/standard-encodings.html>`_.
 
813
 
 
814
If this value is ``None`` then no encoding is done when ``write`` is called.
 
815
 
 
816
 
 
817
default_encoding
 
818
~~~~~~~~~~~~~~~~
 
819
 
 
820
If encoding is set, any byte-strings in your ConfigObj instance (keys or
 
821
members) will first be decoded to unicode using the encoding specified by the
 
822
``default_encoding`` attribute. This ensures that the output is in the encoding
 
823
specified.
 
824
 
 
825
If this value is ``None`` then ``sys.defaultencoding`` is used instead.
 
826
 
652
827
The Config File Format
653
828
======================
654
829
 
943
1118
Section Methods
944
1119
---------------
945
1120
 
946
 
* 'dict'
 
1121
* **dict**
947
1122
 
948
1123
    This method takes no arguments. It returns a deep copy of the section as a
949
1124
    dictionary. All subsections will also be dictionaries, and list values will
950
1125
    be copies, rather than references to the original [#]_.
951
1126
 
952
 
* rename
 
1127
* **rename**
953
1128
 
954
1129
    ``rename(oldkey, newkey)``
955
1130
 
958
1133
    It is mainly implemented for the ``encode`` and ``decode`` methods, which
959
1134
    provide some Unicode support.
960
1135
 
961
 
* walk
 
1136
* **merge**
 
1137
 
 
1138
    ``merge(indict)``
 
1139
    
 
1140
    This method is a *recursive update* method. It allows you to merge two
 
1141
    config files together.
 
1142
    
 
1143
    You would typically use this to create a default ConfigObj and then merge
 
1144
    in user settings. This way users only need to specify values that are
 
1145
    different from the default.
 
1146
    
 
1147
    For example :
 
1148
    
 
1149
    .. raw:: html
 
1150
    
 
1151
        {+coloring}
 
1152
        
 
1153
        # def_cfg contains your default config settings
 
1154
        # user_cfg contains the user settings
 
1155
        cfg = ConfigObj(def_cfg)
 
1156
        usr = ConfigObj(user_cfg)
 
1157
        #
 
1158
        cfg.merge(usr)
 
1159
        
 
1160
        """
 
1161
        cfg now contains a combination of the default settings and the user
 
1162
        settings.
 
1163
        
 
1164
        The user settings will have overwritten any of the default ones.
 
1165
        """
 
1166
    
 
1167
        {-coloring}
 
1168
    
 
1169
* **walk**
962
1170
 
963
1171
    This method can be used to transform values and names. See `walking a
964
1172
    section`_ for examples and explanation.
965
1173
 
966
 
* decode
 
1174
* **decode**
967
1175
 
968
1176
    ``decode(encoding)``
969
1177
 
970
1178
    This method decodes names and values into Unicode objects, using the
971
1179
    supplied encoding.
972
1180
 
973
 
    Because of the way ConfigObj reads files, config files should be in an
974
 
    ASCII compatible encoding. See encodings_ for more details.
975
 
 
976
 
* encode
 
1181
* **encode**
977
1182
 
978
1183
    ``encode(encoding)``
979
1184
 
981
1186
 
982
1187
    It encodes names and values using the supplied encoding. If any of your
983
1188
    names/values are strings rather than Unicode, Python will have to do an
984
 
    implicit decode first.
985
 
 
986
 
    See encodings_ for more details.
987
 
 
 
1189
    implicit decode first. (This method uses ``sys.defaultencoding`` for
 
1190
    implicit decodes.)
 
1191
 
 
1192
* **as_bool**
 
1193
 
 
1194
    ``as_bool(key)``
 
1195
    
 
1196
    Returns ``True`` if the key contains a string that represents ``True``, or
 
1197
    is the ``True`` object.
 
1198
    
 
1199
    Returns ``False`` if the key contains a string that represents ``False``, 
 
1200
    or is the ``False`` object. 
 
1201
 
 
1202
    Raises a ``ValueError`` if the key contains anything else.
 
1203
    
 
1204
    Strings that represent ``True`` are (not case sensitive) : ::
 
1205
    
 
1206
        true, yes, on, 1
 
1207
        
 
1208
    Strings that represent ``False`` are : ::
 
1209
    
 
1210
        false, no, off, 0
 
1211
    
 
1212
    .. note::
 
1213
    
 
1214
        In ConfigObj 4.1.0, this method was called ``istrue``. That method is
 
1215
        now deprecated and will issue a warning when used. It will go away
 
1216
        in the next release.
 
1217
        
 
1218
* **as_int**
 
1219
 
 
1220
    ``as_int(key)``
 
1221
    
 
1222
    This returns the value contained in the specified key as an integer.
 
1223
    
 
1224
    It raises a ``ValueError`` if the conversion can't be done.
 
1225
 
 
1226
* **as_float**
 
1227
 
 
1228
    ``as_float(key)``
 
1229
    
 
1230
    This returns the value contained in the specified key as a float.
 
1231
    
 
1232
    It raises a ``ValueError`` if the conversion can't be done.
 
1233
    
988
1234
Walking a Section
989
1235
-----------------
990
1236
 
1028
1274
If you are using the return value from ``walk`` *and* ``call_on_sections``,
1029
1275
note that walk discards the return value when it calls your function.
1030
1276
 
 
1277
.. caution::
 
1278
 
 
1279
    You can use ``walk`` to transform the names of members of a section
 
1280
    but you mustn't add or delete members.
 
1281
 
 
1282
 
1031
1283
Examples
1032
1284
--------
1033
1285
 
1040
1292
 
1041
1293
You can use this for transforming all values in your ConfigObj. For example
1042
1294
you might like the nested lists from ConfigObj 3. This was provided by the
1043
 
listquote_ module [#]_. You could switch off the parsing for list values
 
1295
listquote_ module. You could switch off the parsing for list values
1044
1296
(``list_values=False``) and use listquote to parse every value.
1045
1297
 
1046
1298
Another thing you might want to do is use the Python escape codes in your
1116
1368
 
1117
1369
    {-coloring}
1118
1370
 
 
1371
Here's a simple example of using ``walk`` to transform names and values. One
 
1372
usecase of this would be to create a *standard* config file with placeholders
 
1373
for section and keynames. You can then use walk to create new config files
 
1374
and change values and member names :
 
1375
 
 
1376
.. raw:: html
 
1377
 
 
1378
    {+coloring}
 
1379
 
 
1380
    # We use 'XXXX' as a placeholder
 
1381
    config = '''
 
1382
    XXXXkey1 = XXXXvalue1
 
1383
    XXXXkey2 = XXXXvalue2
 
1384
    XXXXkey3 = XXXXvalue3
 
1385
    [XXXXsection1]
 
1386
    XXXXkey1 = XXXXvalue1
 
1387
    XXXXkey2 = XXXXvalue2
 
1388
    XXXXkey3 = XXXXvalue3
 
1389
    [XXXXsection2]
 
1390
    XXXXkey1 = XXXXvalue1
 
1391
    XXXXkey2 = XXXXvalue2
 
1392
    XXXXkey3 = XXXXvalue3
 
1393
        [[XXXXsection1]]
 
1394
        XXXXkey1 = XXXXvalue1
 
1395
        XXXXkey2 = XXXXvalue2
 
1396
        XXXXkey3 = XXXXvalue3
 
1397
    '''.splitlines()
 
1398
    cfg = ConfigObj(config)
 
1399
    #
 
1400
    def transform(section, key):
 
1401
        val = section[key]
 
1402
        newkey = key.replace('XXXX', 'CLIENT1')
 
1403
        section.rename(key, newkey)
 
1404
        if isinstance(val, (tuple, list, dict)):
 
1405
            pass
 
1406
        else:
 
1407
            val = val.replace('XXXX', 'CLIENT1')
 
1408
            section[newkey] = val
 
1409
    #
 
1410
    cfg.walk(transform, call_on_sections=True)
 
1411
    print cfg
 
1412
    {'CLIENT1key1': 'CLIENT1value1', 'CLIENT1key2': 'CLIENT1value2', 
 
1413
    'CLIENT1key3': 'CLIENT1value3', 
 
1414
    'CLIENT1section1': {'CLIENT1key1': 'CLIENT1value1', 
 
1415
        'CLIENT1key2': 'CLIENT1value2', 'CLIENT1key3': 'CLIENT1value3'}, 
 
1416
    'CLIENT1section2': {'CLIENT1key1': 'CLIENT1value1', 
 
1417
        'CLIENT1key2': 'CLIENT1value2', 'CLIENT1key3': 'CLIENT1value3', 
 
1418
        'CLIENT1section1': {'CLIENT1key1': 'CLIENT1value1', 
 
1419
            'CLIENT1key2': 'CLIENT1value2', 'CLIENT1key3': 'CLIENT1value3'}}}
 
1420
            
 
1421
    {-coloring}
 
1422
 
 
1423
 
1119
1424
Exceptions
1120
1425
==========
1121
1426
 
1127
1432
    raised.
1128
1433
 
1129
1434
2) If you try to set a non-string key, or a non string value when
1130
 
    ``stringify=False`, a ``TypeError`` will be raised.
 
1435
    ``stringify=False``, a ``TypeError`` will be raised.
1131
1436
 
1132
1437
3) A badly built config file will cause parsing errors.
1133
1438
 
1204
1509
    list of all the lines that caused errors may not be as useful as it sounds.
1205
1510
    {sm;:-(}.
1206
1511
 
 
1512
 
1207
1513
Validation
1208
1514
==========
1209
1515
 
1262
1568
For full details on writing configspecs, please refer to the `validate.py
1263
1569
documentation`_.
1264
1570
 
 
1571
.. important::
 
1572
 
 
1573
    Your configspec is read by ConfigObj in the same way as a config file.
 
1574
    
 
1575
    That means you can do interpolation *within* your configspec.
 
1576
    
 
1577
    In order to allow this, checks in the 'DEFAULT' section (of the root level
 
1578
    of your configspec) are *not* used.
 
1579
 
1265
1580
.. _validate.py documentation: http://www.voidspace.org.uk/python/validate.html
1266
1581
 
1267
1582
Type Conversion
1305
1620
 
1306
1621
    Note that ``default=None`` is case sensitive.
1307
1622
 
 
1623
 
 
1624
List Values
 
1625
~~~~~~~~~~~
 
1626
 
 
1627
It's possible that you will want to specify a list as a default value. To avoid
 
1628
confusing syntax with commas and quotes you use a list constructor to specify 
 
1629
that keyword arguments are lists. This includes the ``default`` value. This 
 
1630
makes checks look something like : ::
 
1631
 
 
1632
    checkname(default=list('val1', 'val2', 'val3'))
 
1633
 
 
1634
This works with all keyword arguments, but is most useful for default values.
 
1635
 
 
1636
 
1308
1637
Repeated Sections
1309
1638
-----------------
1310
1639
 
1404
1733
 
1405
1734
    {-coloring}
1406
1735
 
 
1736
 
1407
1737
Interpolation
1408
1738
=============
1409
1739
 
1434
1764
See `Validation and Interpolation`_. (This can only happen if validation
1435
1765
has to *change* the value).
1436
1766
 
 
1767
 
1437
1768
Comments
1438
1769
========
1439
1770
 
1459
1790
 
1460
1791
These comments are all written back out by the ``write`` method.
1461
1792
 
1462
 
Encodings
1463
 
=========
1464
 
 
1465
 
ConfigObj 4 is designed to work with ASCII compatible encodings [#]_. If you
1466
 
need support for other character sets, then I suggest you use the UTF8
1467
 
encoding for your config files.
1468
 
 
1469
 
By default ConfigObj leaves keys/members as encoded byte strings (ordinary
1470
 
strings). If you want to access the config file members as Unicode objects
1471
 
rather than strings, you can use the ``decode`` method. This takes an encoding
1472
 
as its argument and decodes all members and keys into Unicode. It will only
1473
 
work if *all* members are byte strings (or lists of strings) , so you should do
1474
 
it before calling ``validate``.
1475
 
 
1476
 
If you want to turn the Unicode strings back into byte strings, you can call
1477
 
the ``encode`` method. This also takes an encoding as its argument and assumes
1478
 
*all* keys/members are Unicode.
1479
 
 
1480
 
If you start working with Unicode strings, you may find you get
1481
 
``UnicodeDecodeError`` or ``UnicodeEncodeError`` in unexpected places. This is
1482
 
because you have forced Python to do an *implicit* encode or decode.
1483
 
 
1484
 
Implicit decodes (and encodes) use the encoding returned by
1485
 
``sys.getdefaultencoding()``. This is *usually* ASCII. This means that if you
1486
 
have any non-ASCII characters, Python doesn't know how to treat them and will
1487
 
raise an error.
1488
 
 
1489
 
This happens if you add a byte string to a Unicode string, compare a byte
1490
 
string to a Unicode string, print a Unicode string, or write it to a file. If
1491
 
you work with Unicode, you should do the appropriate encode or decode first.
 
1793
 
 
1794
flatten_errors
 
1795
==============
 
1796
 
 
1797
::
 
1798
 
 
1799
    flatten_errors(cfg, res)
 
1800
 
 
1801
Validation_ is a powerful way of checking that the values supplied by the user
 
1802
make sense.
 
1803
 
 
1804
The validate_ method returns a results dictionary that represents pass or fail
 
1805
for each value. This doesn't give you any information about *why* the check
 
1806
failed.
 
1807
 
 
1808
``flatten_errors`` is an example function that turns a results dictionary into
 
1809
a flat list, that only contains vaues that *failed*.
 
1810
 
 
1811
``cfg`` is the ConfigObj instance being checked, ``res`` is the results
 
1812
dictionary returned by ``validate``.
 
1813
 
 
1814
It returns a list of keys that failed. Each member of the list is a tuple : ::
 
1815
 
 
1816
    ([list of sections...], key, result)
 
1817
 
 
1818
If ``validate`` was called with ``preserve_errors=False`` (the default)
 
1819
then ``result`` will always be ``False``.
 
1820
 
 
1821
*list of sections* is a flattened list of sections that the key was found
 
1822
in.
 
1823
 
 
1824
If the section was missing then key will be ``None``.
 
1825
 
 
1826
If the value (or section) was missing then ``result`` will be ``False``.
 
1827
 
 
1828
If ``validate`` was called with ``preserve_errors=True`` and a value
 
1829
was present, but failed the check, then ``result`` will be the exception
 
1830
object returned. You can use this as a string that describes the failure.
 
1831
 
 
1832
For example :
 
1833
 
 
1834
    *The value "3" is of the wrong type*.
 
1835
 
 
1836
 
 
1837
Example Usage
 
1838
-------------
 
1839
 
 
1840
The output from ``flatten_errors`` is a list of tuples.
 
1841
 
 
1842
Here is an example of how you could present this information to the user.
 
1843
 
 
1844
.. raw:: html
 
1845
 
 
1846
    {+coloring}
 
1847
    
 
1848
    vtor = validate.Validator()
 
1849
    # ini is your config file - cs is the configspec
 
1850
    cfg = ConfigObj(ini, configspec=cs)
 
1851
    res = cfg.validate(vtor, preserve_errors=True)
 
1852
    for entry in flatten_errors(cfg, res):
 
1853
        # each entry is a tuple
 
1854
        section_list, key, error = entry
 
1855
        if key is not None:
 
1856
           section_list.append(key)
 
1857
        else:
 
1858
            section_list.append('[missing section]')
 
1859
        section_string = ', '.join(section_list)
 
1860
        if error == False:
 
1861
            error = 'Missing value or section.'
 
1862
        print section_string, ' = ', error
 
1863
 
 
1864
    {-coloring}
1492
1865
 
1493
1866
Backwards Compatibility
1494
1867
=======================
1546
1919
 
1547
1920
The ``newline``, ``force_return``, and ``default`` options have gone.
1548
1921
 
1549
 
The ``encoding`` and ``backup_encoding`` methods have gone, replaced with the
1550
 
``encode`` and ``decode`` methods.
1551
 
 
1552
1922
``fileerror`` and ``createempty`` options have become ``file_error`` and
1553
1923
``create_empty``.
1554
1924
 
1580
1950
.. _ConfigObj 3.3.1: http://www.voidspace.org.uk/cgi-bin/voidspace/downman.py?file=configobj3.zip
1581
1951
.. _ConfigObj 3 Docs: http://www.voidspace.org.uk/python/configobj3.html
1582
1952
 
 
1953
 
1583
1954
CREDITS
1584
1955
=======
1585
1956
 
1593
1964
 
1594
1965
Thanks to others for input and bugfixes.
1595
1966
 
 
1967
 
1596
1968
LICENSE
1597
1969
=======
1598
1970
 
1602
1974
Of course if it does, let us know and we'll fix the problem so it doesn't
1603
1975
happen to anyone else {sm;:-)}. ::
1604
1976
 
1605
 
    Copyright (c) 2004 & 2005, Michael Foord & Nicola Larosa
 
1977
    Copyright (c) 2004 - 2006, Michael Foord & Nicola Larosa
1606
1978
    All rights reserved.
1607
1979
 
1608
1980
    Redistribution and use in source and binary forms, with or without
1636
2008
 
1637
2009
You should also be able to find a copy of this license at : `BSD License`_
1638
2010
 
1639
 
.. _BSD License: http://www.voidspace.org.uk/documents/BSD-LICENSE.txt
 
2011
.. _BSD License: http://www.voidspace.org.uk/python/license.shtml
 
2012
 
1640
2013
 
1641
2014
TODO
1642
2015
====
1649
2022
When initialising a section from a ConfigObj *or* an ``OrderedDictionary``
1650
2023
we could preserve ordering.
1651
2024
 
1652
 
Add an *odict* method which returns an `OrderedDictionary``.
 
2025
Add an *odict* method which returns an ``OrderedDictionary``.
 
2026
 
1653
2027
 
1654
2028
ISSUES
1655
2029
======
1656
2030
 
1657
2031
.. note::
1658
2032
 
1659
 
    Please file any bug reports to `Michael Foord`_ or the ConfigObj
 
2033
    Please file any bug reports to `Michael Foord`_ or the **ConfigObj**
1660
2034
    `Mailing List`_.
1661
2035
 
1662
2036
You can't have a keyword with the same name as a section (in the same section).
1670
2044
parent*: this means that checking the 'DEFAULT' sub-section in the *current
1671
2045
section* is not necessarily logical ?
1672
2046
 
1673
 
In order to simplify Unicode support (which is possibly of limited value
1674
 
in a config file ?) I have removed automatic support, and added thev``encode``
1675
 
and ``decode`` methods. These can be used to transform keys and entries.
1676
 
Because the regex looks for specific values on inital parsing (i.e. the quotes
1677
 
and the equals signs) it can only read ASCII compatible encodings. For Unicode
1678
 
I suggest ``UTF8``, which is ASCII compatible.
1679
 
 
1680
 
.. note::
1681
 
 
1682
 
    There is no reason why you shouldn't decode your config file into Unicode
1683
 
    before passing them to ConfigObj (as a list of lines). This should give you
1684
 
    Unicode keys and values.
1685
 
 
1686
2047
Does it matter that we don't support the ':' divider, which is supported by
1687
2048
``ConfigParser`` ?
1688
2049
 
1689
 
Following error with "list_values=False" : ::
1690
 
 
1691
 
    >>> a = ["a='hello', 'goodbye'"]
1692
 
    >>>
1693
 
    >>> c(a, list_values=False)
1694
 
    {'a': "hello', 'goodbye"}
1695
 
 
1696
 
The regular expression correctly removes the value - ``"'hello', 'goodbye'"`` -
1697
 
and then unquote just removes the front and back quotes (called by
1698
 
``_handle_value``). What should we do ?? We *ought* to raise an exception - 
1699
 
because if lists are off it's an invalid value. This is not desired if you want 
1700
 
to do your own list processing e.g. using listquote for nested lists. It would
1701
 
be *better* in this case not to unquote. Raising an exception would require a
1702
 
new regex.
1703
 
 
1704
2050
String interpolation and validation don't play well together. See 
1705
2051
`Validation and Interpolation`_.
1706
2052
 
 
2053
Validation is no longer done on the 'DEFAULT' section (on the root level). This
 
2054
allows interpolation from within your configspec - but also prevents you
 
2055
validating the 'DEFAULT' section.
 
2056
 
 
2057
 
1707
2058
CHANGELOG
1708
2059
=========
1709
2060
 
1711
2062
From version 4 it lists all releases and changes. *More* data on individual
1712
2063
changes may be found in the source code.
1713
2064
 
 
2065
2006/02/16 - Version 4.2.0
 
2066
--------------------------
 
2067
 
 
2068
Removed ``BOM_UTF8`` from ``__all__``.
 
2069
 
 
2070
The ``BOM`` attribute has become a boolean. (Defaults to ``False``.) It is
 
2071
*only* ``True`` for the ``UTF16`` encoding.
 
2072
 
 
2073
File like objects no longer need a ``seek`` attribute.
 
2074
 
 
2075
Full unicode support added. New options/attributes ``encoding``,
 
2076
``default_encoding``.
 
2077
 
 
2078
ConfigObj no longer keeps a reference to file like objects. Instead the
 
2079
``write`` method takes a file like object as an optional argument. (Which
 
2080
will be used in preference of the ``filename`` attribute if that exists as
 
2081
well.)
 
2082
 
 
2083
utf16 files decoded to unicode.
 
2084
 
 
2085
If ``BOM`` is ``True``, but no encoding specified, then the utf8 BOM is
 
2086
written out at the start of the file. (It will normally only be ``True`` if
 
2087
the utf8 BOM was found when the file was read.)
 
2088
 
 
2089
File paths are *not* converted to absolute paths, relative paths will
 
2090
remain relative as the ``filename`` attribute.
 
2091
 
 
2092
Fixed bug where ``final_comment`` wasn't returned if ``write`` is returning
 
2093
a list of lines.
 
2094
 
 
2095
Deprecated ``istrue``, replaced it with ``as_bool``.
 
2096
 
 
2097
Added ``as_int`` and ``as_float``.
 
2098
 
 
2099
2005/12/14 - Version 4.1.0
 
2100
--------------------------
 
2101
 
 
2102
Added ``merge``, a recursive update.
 
2103
 
 
2104
Added ``preserve_errors`` to ``validate`` and the ``flatten_errors``
 
2105
example function.
 
2106
 
 
2107
Thanks to Matthew Brett for suggestions and helping me iron out bugs.
 
2108
    
 
2109
Fixed bug where a config file is *all* comment, the comment will now be
 
2110
``initial_comment`` rather than ``final_comment``.
 
2111
 
 
2112
Validation no longer done on the 'DEFAULT' section (only in the root level).
 
2113
This allows interpolation in configspecs.
 
2114
 
 
2115
Also use the new list syntax in validate_ 0.2.1. (For configspecs).
 
2116
 
 
2117
2005/12/02 - Version 4.0.2
 
2118
--------------------------
 
2119
 
 
2120
Fixed bug in ``create_empty``. Thanks to Paul Jimenez for the report.
 
2121
 
 
2122
 
 
2123
2005/11/05 - Version 4.0.1
 
2124
--------------------------
 
2125
 
 
2126
Fixed bug in ``Section.walk`` when transforming names as well as values.
 
2127
 
 
2128
Added the ``istrue`` method. (Fetches the boolean equivalent of a string
 
2129
value).
 
2130
 
 
2131
Fixed ``list_values=False`` - they are now only quoted/unquoted if they
 
2132
are multiline values.
 
2133
 
 
2134
List values are written as ``item, item`` rather than ``item,item``.
 
2135
 
 
2136
 
1714
2137
2005/10/17 - Version 4.0.0
1715
2138
--------------------------
1716
2139
 
1878
2301
Footnotes
1879
2302
=========
1880
2303
 
1881
 
.. [#] The core parser is now based on regular expressions, so it's a lot
1882
 
    faster.
1883
 
 
1884
 
.. [#] 134 of them, at the time of writing.
 
2304
.. [#] 253 of them, at the time of writing.
1885
2305
 
1886
2306
.. [#] And if you discover any bugs, let us know. We'll fix them quickly.
1887
2307
 
1888
2308
.. [#] If you specify a filename that doesn't exist, ConfigObj will assume you
1889
2309
    are creating a new one. See the *create_empty* and *file_error* options_.
1890
2310
 
1891
 
.. [#] They can be byte strings ('ordinary' strings) or Unicode. If they are
1892
 
    Unicode then ConfigObj will have to do an implicit encode before writing.
1893
 
    See the encodings_ section for more details.
 
2311
.. [#] They can be byte strings ('ordinary' strings) or Unicode.
 
2312
 
 
2313
.. [#] This is a change in ConfigObj 4.2.0. Note that ConfigObj doesn't call
 
2314
    the seek method of any file like object you pass in. You may want to call
 
2315
    ``file_object.seek(0)`` yourself, first.
1894
2316
 
1895
2317
.. [#] Except we don't support the RFC822 style line continuations, nor ':' as
1896
2318
    a divider.
1901
2323
 
1902
2324
.. [#] A side effect of this is that it enables you to copy a ConfigObj :
1903
2325
 
1904
 
.. raw:: html
1905
 
 
1906
 
    {+coloring}
1907
 
 
1908
 
    # only copies members
1909
 
    # not attributes/comments
1910
 
    config2 = ConfigObj(config1)
1911
 
 
1912
 
    {-coloring}
1913
 
 
1914
 
..
 
2326
    .. raw:: html
 
2327
    
 
2328
        {+coloring}
 
2329
    
 
2330
        # only copies members
 
2331
        # not attributes/comments
 
2332
        config2 = ConfigObj(config1)
 
2333
    
 
2334
        {-coloring}
1915
2335
 
1916
2336
    The order of values and sections will not be preserved, though.
1917
2337
 
 
2338
.. [#] The exception is if it detects a ``UTF16`` encoded file which it
 
2339
    must decode before parsing.
 
2340
     
1918
2341
.. [#] Other than lists of strings.
1919
2342
 
1920
 
.. [#] The method signature in the API docs will show that it does in fact
1921
 
    take one argument: the section to be written. This is because the
1922
 
    ``write`` method is called recursively. Using this argument *forces* write
1923
 
    to return a list of lines, so it's probably not very useful to you.
 
2343
.. [#] The method signature in the API docs will show that this method takes
 
2344
    two arguments. The second is the section to be written. This is because the
 
2345
    ``write`` method is called recursively.
1924
2346
 
1925
2347
.. [#] The dict method doesn't actually use the deepcopy mechanism. This means
1926
2348
    if you add nested lists (etc) to your ConfigObj, then the dictionary
1931
2353
    change the value by setting ``section[key] = newval``. It also gives you
1932
2354
    access to the *rename* method of the section.
1933
2355
 
1934
 
.. [#] A current bug in unquoting when ``list_values=False`` currently makes
1935
 
    this impossible. We are considering the best way to fix this.
1936
 
 
1937
2356
.. [#] Minimum required version of *validate.py* 0.2.0 .
1938
2357
 
1939
2358
.. [#] There's nothing to stop you decoding the whole config file to Unicode
1959
2378
        <br />
1960
2379
        <a href="http://www.python.org">
1961
2380
            <img src="images/powered_by_python.jpg" width="602" height="186" border="0" />
1962
 
        </a>
 
2381
        </a><br /><br />
1963
2382
        <a href="http://www.opensource.org">
1964
2383
            <img src="images/osi-certified-120x100.gif" width="120" height="100" border="0" />
1965
2384
            <br /><strong>Certified Open Source</strong>
1972
2391
                <img src="http://s16.sitemeter.com/meter.asp?site=s16atlantibots" alt="Site Meter" border=0 />
1973
2392
            </a>
1974
2393
        </noscript>
1975
 
        <br />
1976
2394
    </div>
1977
2395
 
1978
2396
.. _listquote: http://www.voidspace.org.uk/python/modules.shtml#listquote
1979
 
.. _Michael Foord: http://www.voidspace.org.uk
 
2397
.. _Michael Foord: http://www.voidspace.org.uk/index2.shtml
1980
2398
.. _Nicola Larosa: http://www.teknico.net
1981
2399
.. _Mark Andrews: http://www.la-la.com