1

"""

     2

    Configuration

     3

"""

     4

     5

import copy, logging

     6

     7

class InstanceContext (object) :

     8

    """

     9

        An object that behaves like a dict, performing all item lookups as attribute lookups on the given object.

    10

    11

        Additionally, it only lets you re-bind existing attributes via setitem, raising AttributeError if setting

    12

        unknown attributes.

    13

    14

        Useful for binding an exec statement's locals.

    15

    """

    16

    17

    def __init__ (self, obj) : self.obj = obj

    18

    def __getitem__ (self, key) : return getattr(self.obj, key)

    19

    def __setitem__ (self, key, value) : 

    20

        """

    21

            Replace the named attribute, asserting that the target has such an attribute.

    22

        """

    23

    24

        # test

    25

        if hasattr(self.obj, key) :

    26

            setattr(self.obj, key, value)

    27

    28

        else :

    29

            raise AttributeError(key)

    30

    31

class ConfigurationMachinery (object) :

    32

    """

    33

        The low-level configuration machinery.

    34

    """

    35

    36

    def import_py (self, path) :

    37

        """

    38

            Import python-style configuration from the given File object into this one.

    39

    40

            This runs the file's code using exec, using a context mapped to this object.

    41

        """

    42

    43

        # the code

    44

        file = open(path)

    45

    46

        # build suitable locals/globals to proxy this object

    47

        locals = InstanceContext(self)

    48

    49

        # run

    50

        exec file in {}, locals

    51

    52

    def import_file (self, path) :

    53

        """

    54

            Import configuration from the given File into this one.

    55

        """

    56

    57

        # as python code

    58

        self.import_py(path)

    59

    60

    def load (self, path) :

    61

        """

    62

            Loads the configuration from the given File, creating a new Configuration with defaults from this one.

    63

        """

    64

    65

        # copy ourself

    66

        new = copy.copy(self)

    67

    68

        # import into it

    69

        new.import_file(path)

    70

    71

        # return

    72

        return new

    73

    74

class Configuration (ConfigurationMachinery) :

    75

    """

    76

        Various configuration settings

    77

    """

    78

    79

    # the path to the gallery root

    80

    # only valid in top-level config

    81

    gallery_path        = "."

    82

    83

    # force-update items

    84

    force_thumb         = False

    85

    force_html          = False

    86

    87

    def get_force_update (self) :

    88

        return self.force_thumb or self.force_html

    89

    90

    def set_force_update (self, value) :

    91

        self.force_thumb = self.force_html = value

    92

    93

    force_update = property(get_force_update, set_force_update)

    94

    95

    # minimum logging level

    96

    log_level           = logging.INFO

    97

    98

    def quiet (self) : self.log_level = logging.WARN

    99

    def debug (self) : self.log_level = logging.DEBUG

   100

   101

    # number of threads to use for concurrency

   102

    # use some heuristic?

   103

    thread_count        = 2

   104

   105

    # the name of this folder, only applies on one level

   106

    # default applies to the root gallery

   107

    title               = "Image Gallery"

   108

   109

    # recognized image extensions, case-insensitive

   110

    image_exts          = ('jpg', 'jpeg', 'png', 'gif', 'bmp')

   111

   112

    # subdirectory names used for generated thumbnails/previews

   113

    thumb_dir           = 'thumbs'

   114

    preview_dir         = 'previews'

   115

   116

    # size of generated thumbnails/previews as (width, height) tuples

   117

    thumb_size          = (160, 120)

   118

    preview_size        = (640, 480)

   119

   120

    # number of images displayed per folder page

   121

    images_per_page     = 50

   122

   123

    # load Exif data for images, this may be slow

   124

    with_exif           = False

   125

   126

    # name of Exif handler to use

   127

    exif_handler_name   = None

   128

   129

    # explicit Exif handler class

   130

    exif_handler        = None

   131

   132

    # exif tags used in output

   133

    # Copyright (C) 2008, Santtu Pajukanta <santtu@pajukanta.fi>

   134

    # XXX: import from dexif?

   135

    exif_tags           = (

   136

        # TODO Create date is in a useless format, needs some strptime love

   137

        ("CreateDate",              "Create date"               ),

   138

        ("Model",                   "Camera model"              ),

   139

        ("Aperture",                "Aperture"                  ),

   140

        ("ExposureMode",            "Exposure mode"             ),

   141

        ("ExposureCompensation",    "Exposure compensation"     ),

   142

        ("ExposureTime",            "Exposure time"             ),

   143

        ("Flash",                   "Flash mode"                ),

   144

        ("ISO",                     "ISO"                       ),

   145

        ("ShootingMode",            "Shooting mode"             ),

   146

        ("LensType",                "Lens type"                 ),

   147

        ("FocalLength",             "Focal length"              ),

   148

    )

   149

   150

    # XXX: move elsewhere?

   151

    def is_image (self, file) :

   152

        """

   153

            Tests if the given File is an image, based on its file extension

   154

   155

        """

   156

   157

        return file.matchext(self.image_exts)

   158