1

#!/usr/bin/env python2.4

     2

#

     3

# DeGAL - A pretty simple web image gallery

     4

# Copyright (C) 2007 Tero Marttila

     5

# http://marttila.de/~terom/degal/

     6

#

     7

# This program is free software; you can redistribute it and/or modify

     8

# it under the terms of the GNU General Public License as published by

     9

# the Free Software Foundation; either version 2 of the License, or

    10

# (at your option) any later version.

    11

#

    12

# This program is distributed in the hope that it will be useful,

    13

# but WITHOUT ANY WARRANTY; without even the implied warranty of

    14

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

    15

# GNU General Public License for more details.

    16

#

    17

# You should have received a copy of the GNU General Public License

    18

# along with this program; if not, write to the

    19

# Free Software Foundation, Inc.,

    20

# 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

    21

#

    22

    23

import os.path, os

    24

import urllib

    25

import logging

    26

import string

    27

from datetime import datetime

    28

import struct

    29

import base64

    30

import shelve

    31

    32

import PIL

    33

import PIL.Image

    34

    35

import utils

    36

    37

__version__ = '0.2'

    38

    39

TEMPLATE_DIR='templates'

    40

TEMPLATE_EXT='html'

    41

    42

logging.basicConfig(

    43

    level=logging.INFO,

    46

    47

)

    48

    49

tpl = logging.getLogger('tpl')

    50

index = logging.getLogger('index')

    51

render = logging.getLogger('render')

    52

    53

tpl.setLevel(logging.WARNING)

    54

    55

#for l in (tpl, index, prepare, render) :

    56

#    l.setLevel(logging.DEBUG)

    57

    58

def readFile (path) :

    59

    fo = open(path, 'r')

    60

    data = fo.read()

    61

    fo.close()

    62

    63

    return data

    64

    65

class Template (object) :

    66

    GLOBALS = dict(

    67

        VERSION=__version__,

    68

    )

    69

    70

    def __init__ (self, name) :

    71

        self.name = name

    72

        self.path = os.path.join(TEMPLATE_DIR, "%s.%s" % (name, TEMPLATE_EXT))

    73

    74

        tpl.debug("Template %s at %s", name, self.path)

    75

    76

        self.content = readFile(self.path)

    77

    78

    def render (self, **vars) :

    79

        content = self.content

    80

    81

        vars.update(self.GLOBALS)

    82

    83

        for name, value in vars.iteritems() :

    84

            content = content.replace('<!-- %s -->' % name, str(value))

    85

    86

        return content

    87

    88

    def renderTo (self, path, **vars) :

    89

        tpl.info("Render %s to %s", self.name, path)

    90

    91

        fo = open(path, 'w')

    92

        fo.write(self.render(**vars))

    93

        fo.close()

    94

    95

gallery_tpl = Template('gallery')

    96

image_tpl = Template('image')

    97

    98

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

    99

   100

THUMB_DIR = 'thumbs'

   101

PREVIEW_DIR = 'previews'

   102

TITLE_FILE = 'title.txt'

   103

   104

THUMB_GEOM = (160, 120)

   105

PREVIEW_GEOM = (640, 480)

   106

   107

DEFAULT_TITLE = 'Image gallery'

   108

   109

# how many image/page

   110

IMAGE_COUNT = 50

   111

   112

def isImage (fname) :

   113

    """

   114

        Is the given filename likely to be an image file?

   115

    """

   116

   117

    fname = fname.lower()

   118

    base, ext = os.path.splitext(fname)

   119

    ext = ext.lstrip('.')

   120

   121

    return ext in IMAGE_EXTS

   122

   123

def link (url, title) :

   124

    """

   125

        Returns an <a href=""></a> link tag with the given values

   126

    """

   127

   128

    return "<a href='%s'>%s</a>" % (urllib.quote(url), title)

   129

   130

def dirUp (count=1) :

   131

    """

   132

        Returns a relative path to the directly count levels above the current one

   133

    """

   134

   135

    if not count :

   136

        return '.'

   137

   138

    return os.path.join(*(['..']*count))

   139

   140

def readTitleDescr (path) :

   141

    """

   142

        Read a title.txt or <imgname>.txt file

   143

    """

   144

   145

    if os.path.exists(path) :

   146

        content = readFile(path)

   147

   148

        if '---' in content :

   149

            title, descr = content.split('---', 1)

   150

        else :

   151

            title, descr = content, ''

   152

   153

        return title.strip(), descr.strip()

   154

   155

    return None, None

   156

   157

class Folder (object) :

   158

    def __init__ (self, name='.', parent=None) :

   159

        # the directory name

   160

        self.name = name

   161

   162

        # our parent Folder, or None

   163

        self.parent = parent

   164

   165

        # the path to this dir, as a relative path to the root of the image gallery, always starts with .

   166

        if parent and name :

   167

            self.path = parent.pathFor(name)

   168

        else :

   169

            self.path = name

   170

   171

        # the url-path to the index.html file

   172

        self.html_path = self.path

   173

   174

        # dict of fname -> Folder

   175

        self.subdirs = {}

   176

   177

        # dict of fname -> Image

   178

        self.images = {}

   179

   180

        # our human-friendly title

   181

        self.title = None

   182

   183

        # our long-winded description

   184

        self.descr = ''

   185

   186

        # is this folder non-empty?

   187

        self.alive = None

   188

   189

        # self.images.values(), but sorted by filename

   190

        self.sorted_images = []

   191

   192

        # the ShortURL key to this dir

   193

        self.shorturl_code = None

   194

   195

        # were we filtered out?

   196

        self.filtered = False

   197

   198

    def pathFor (self, *fnames) :

   199

        """

   200

            Return a root-relative path to the given path inside this dir

   201

        """

   202

        return os.path.join(self.path, *fnames)

   203

   204

    def index (self, filters=None) :

   205

        """

   206

            Look for other dirs and images inside this dir. Filters must be either None,

   207

            whereupon all files will be included, or a dict of {filename -> next_filter}.

   208

            If given, only filenames that are present in the dict will be indexed, and in

   209

            the case of dirs, the next_filter will be passed on to that Folder's index

   210

            method.

   211

        """

   212

   213

        index.info("Indexing %s", self.path)

   214

   215

        if filters :

   216

            self.filtered = True

   217

   218

        # iterate through listdir

   219

        for fname in os.listdir(self.path) :

   220

            # the full filesystem path to it

   221

            fpath = self.pathFor(fname)

   222

   223

            # ignore dotfiles

   224

            if fname.startswith('.') :

   225

                index.debug("Skipping dotfile %s", fname)

   226

                continue

   227

   228

            # apply filters

   229

            if filters :

   230

                if fname in filters :

   231

                    next_filter = filters[fname]

   232

                else :

   233

                    index.debug("Skip `%s' as we have a filter", fname)

   234

                    continue

   235

            else :

   236

                next_filter = None

   237

   238

            # recurse into subdirs, but not thumbs/previews

   239

            if os.path.isdir(fpath) and fname not in (THUMB_DIR, PREVIEW_DIR) :

   240

                index.debug("Found subdir %s", fpath)

   241

                f = self.subdirs[fname] = Folder(fname, self)

   245

   246

            # handle images

   247

            elif os.path.isfile(fpath) and isImage(fname) :

   248

                index.debug("Found image %s", fname)

   249

                self.images[fname] = Image(self, fname)

   250

   251

            # ignore everything else

   252

            else :

   253

                index.debug("Ignoring file %s", fname)

   254

   258

   259

            # sort the images

   260

            fnames = self.images.keys()

   261

            fnames.sort()

   263

            prev = None

   266

            for fname in fnames :

   267

                img = self.images[fname]

   268

   269

                img.prev = prev

   270

   271

                if prev :

   272

                    prev.next = img

   273

   274

                prev = img

   275

   276

                # add to the sorted images list

   277

                self.sorted_images.append(img)

   278

   280

   281

    def getObjInfo (self) :

   282

        """

   283

            Metadata for shorturls2.db

   284

        """

   285

        return 'dir', self.path, 'index'

   286

   287

    def linkTag (self) :

   288

        """

   289

            A text-link to this dir

   290

        """

   291

   292

        return link(self.path, self.title)

   293

   294

    def breadcrumb (self) :

   295

        """

   296

            Returns a [(fname, title)] list of this dir's parent dirs

   297

        """

   298

   299

        f = self

   300

        b = []

   301

        d = 0

   302

   303

        while f :

   304

            b.insert(0, (dirUp(d), f.title))

   305

   306

            d += 1

   307

            f = f.parent

   308

   309

        return b

   310

   311

    def inRoot (self, *fnames) :

   312

        """

   313

            Return a relative URL from this dir to the given path in the root dir

   314

        """

   315

   316

        c = len(self.path.split('/')) - 1

   317

   318

        return os.path.join(*((['..']*c) + list(fnames)))

   319

   320

    def _page_fname (self, page) :

   321

        assert page >= 0

   322

   323

        if page > 0 :

   324

            return  'index_%d.html' % page

   325

        else :

   326

            return 'index.html'

   327

   328

    def render (self) :

   329

        """

   330

            Render the index.html, Images, and recurse into subdirs

   331

        """

   332

   333

        # ded folders are skipped

   334

        if not self.alive :

   335

            render.info("Skipping dir %s", self.path)

   336

            return

   337

   338

        # if this dir's contents were filtered out, then we can't render the index.html, as we aren't aware of all the images in here

   339

        if self.filtered :

   340

            render.warning("Dir `%s' contents were filtered, so we won't render the gallery index again", self.path)

   341

   367

            # sort the subdirs

   368

            subdirs = self.subdirs.items()

   369

            subdirs.sort()

   370

   371

            # generate the <a href=""></a>'s for the subdirs

   372

            subdir_linkTags = [link(f.name, f.title) for fname, f in subdirs if f.alive]

   373

   374

            # stick them into a list

   375

            if subdir_linkTags :

   376

                directories = "<ul>\n\t<li>%s</li>\n</ul>" % "</li>\n\t<li>".join(subdir_linkTags)

   377

            else :

   378

                directories = ''

   379

   380

            render.info("Rendering %s", self.path)

   381

   382

            # paginate!

   383

            images = self.sorted_images

   384

            image_count = len(images)

   385

            pages = []

   386

   387

            while images :

   388

                pages.append(images[:IMAGE_COUNT])

   389

                images = images[IMAGE_COUNT:]

   390

   391

            pagination_required = len(pages) > 1

   392

   393

            if pagination_required :

   394

                render.info("Index split into %d pages of %d images each", len(pages), IMAGE_COUNT)

   395

   396

            for cur_page, page in enumerate(pages) :

   397

                if pagination_required :

   398

                    pagination = "<ul>" # <li>Showing Images %d - %d of %d</li>" % (cur_page*IMAGE_COUNT, cur_page*IMAGE_COUNT+len(page), image_count)

   399

   400

                    if cur_page > 0 :

   401

                        pagination += '<li><a href="%s">&laquo; Prev</a></li>' % (self._page_fname(cur_page - 1))

   402

                    else :

   403

                        pagination += '<li><span>&laquo; Prev</span></li>'

   404

   405

                    for x in xrange(0, len(pages)) :

   406

                        if x == cur_page :

   407

                            pagination += '<li><strong>%s</strong></li>' % (x + 1)

   408

                        else :

   409

                            pagination += '<li><a href="%s">%s</a></li>' % (self._page_fname(x), x+1)

   410

   411

                    if cur_page < len(pages) - 1 :

   412

                        pagination += '<li><a href="%s">Next &raquo;</a></li>' % (self._page_fname(cur_page + 1))

   413

                    else :

   414

                        pagination += '<li><span>Next &raquo;</span></li>'

   415

   416

                    pagination += "</ul>"

   417

                    shorturl = "%s/%s" % (self.shorturl_code, cur_page+1)

   418

                else :

   419

                    pagination = ''

   420

                    shorturl = self.shorturl_code

   421

   422

                # render to index.html

   423

                gallery_tpl.renderTo(self.pathFor(self._page_fname(cur_page)), 

   424

                    STYLE_URL=self.inRoot('style.css'),

   425

                    BREADCRUMB=" » ".join([link(u, t) for (u, t) in self.breadcrumb()]),

   426

                    TITLE=self.title,

   427

                    DIRECTORIES=directories,

   428

                    PAGINATION=pagination,

   429

                    CONTENT="".join([i.thumbImgTag() for i in page]),

   430

                    DESCR=self.descr,

   431

                    SHORTURL=self.inRoot('s', shorturl),

   432

                    SHORTURL_CODE=shorturl,

   433

                )

   434

   435

        # render images

   436

        for img in self.images.itervalues() :

   437

            img.render()

   438

   439

        # recurse into subdirs

   440

        for dir in self.subdirs.itervalues() :

   441

            dir.render()

   442

   443

class Image (object) :

   444

    def __init__ (self, dir, name) :

   445

        # the image filename, e.g. DSC3948.JPG

   446

        self.name = name

   447

   448

        # the Folder object that we are in

   449

        self.dir = dir

   450

   451

        # the relative path from the root to us

   452

        self.path = dir.pathFor(name)

   453

   454

        # the basename+ext, e.g. DSCR3948, .JPG

   455

        self.base_name, self.ext = os.path.splitext(name)

   456

   457

        # the root-relative paths to the thumb and preview images

   458

        self.thumb_path = self.dir.pathFor(THUMB_DIR, self.name)

   459

        self.preview_path = self.dir.pathFor(PREVIEW_DIR, self.name)

   460

   461

        # our user-friendly title

   462

        self.title = name

   463

   464

        # our long-winded description

   465

        self.descr = ''

   466

   467

        # the image before and after us, both may be None

   468

        self.prev = self.next = None

   469

   470

        # the name of the .html gallery view thing for this image, *always* self.name + ".html"

   471

        self.html_name = self.name + ".html"

   472

   473

        # the root-relative path to the gallery view

   474

        self.html_path = self.dir.pathFor(self.html_name)

   475

   476

        #

   477

        # Figured out after prepare

   478

        #

   479

   480

        # (w, h) tuple

   481

        self.img_size = None

   482

   483

        # the ShortURL code for this image

   484

        self.shorturl_code = None

   485

   486

        # what to use in the rendered templates, intended to be overridden by subclasses

   487

        self.series_act = "add"

   488

        self.series_verb = "Add to"

   489

   490

    def getObjInfo (self) :

   491

        """

   492

            Metadata for shorturl2.db

   493

        """

   494

        return 'img', self.dir.path, self.name

   495

   496

    def thumbImgTag (self) :

   497

        """

   498

            a <a><img /></a> of this image's thumbnail. Path relative to directory we are in

   499

        """

   500

        return link(self.html_name, "<img src='%s' alt='%s' title='%s' />" % (os.path.join(THUMB_DIR, self.name), self.descr, self.title))

   501

   502

    def previewImgTag (self) :

   503

        """

   504

            a <a><img /></a> of this image's preview. Path relative to directory we are in

   505

        """

   506

        return link(self.name, "<img src='%s' alt='%s' title='%s' />" % (os.path.join(PREVIEW_DIR, self.name), self.descr, self.title))

   507

   508

    def linkTag (self) :

   509

        """

   510

            a <a></a> text-link to this image

   511

        """

   512

        return link(self.html_name, self.title)

   513

   514

    def breadcrumb (self) :

   515

        """

   516

            Returns a [(fname, title)] list of this image's parents

   517

        """

   518

   519

        f = self.dir

   520

        b = [(self.html_name, self.title)]