Note: v0.2.X cleans up some cruft from v0.1.X. v0.2.X still passes the same tests as v0.1.X, but removes a lot of functionality unrelated to luigi. Please check, before you upgrade.
Luigi 2.0 compatibility: gluish 0.2.3 or higher.
Note that luigi dropped Python 2 support, and so does this package, starting with 0.3.0.
Some glue around luigi.
Provides a base class, that autogenerates its output filenames based on
- some base path,
- a tag,
- the task id (the classname and the significant parameters)
Additionally, this package provides a few smaller utilities, like a TSV format, a benchmarking decorator and some task templates.
This project has been developed for Project finc at Leipzig University Library.
gluish.task.BaseTask is intended to be used as a supertask.
from gluish.task import BaseTask
import datetime
import luigi
import tempfile
class DefaultTask(BaseTask):
""" Some default abstract task for your tasks. BASE and TAG determine
the paths, where the artefacts will be stored. """
BASE = tempfile.gettempdir()
TAG = 'just-a-test'
class RealTask(DefaultTask):
""" Note that this task has a `self.path()`, that figures out the full
path for this class' output. """
date = luigi.DateParameter(default=datetime.date(1970, 1, 1))
def run(self):
with self.output().open('w') as output:
output.write('Hello World!')
def output(self):
return luigi.LocalTarget(path=self.path())When instantiating a RealTask instance, it will automatically be assigned a
structured output path, consisting of BASE, TAG, task name and a slugified
version of the significant parameters.
task = RealTask()
task.output().path
# would be something like this on OS X:
# /var/folders/jy/g_b2kpwx0850/T/just-a-test/RealTask/date-1970-01-01.tsvWas started on the
mailing list.
Continuing the example from above, lets create a task, that generates TSV
files, named TabularSource.
from gluish.format import TSV
class TabularSource(DefaultTask):
date = luigi.DateParameter(default=datetime.date(1970, 1, 1))
def run(self):
with self.output().open('w') as output:
for i in range(10):
output.write_tsv(i, 'Hello', 'World')
def output(self):
return luigi.LocalTarget(path=self.path(), format=TSV)Another class, TabularConsumer can use iter_tsv on the handle obtained
by opening the file. The row will be a tuple, or - if cols is specified -
a collections.namedtuple.
class TabularConsumer(DefaultTask):
date = luigi.DateParameter(default=datetime.date(1970, 1, 1))
def requires(self):
return TabularSource()
def run(self):
with self.input().open() as handle:
for row in handle.iter_tsv(cols=('id', 'greeting', 'greetee'))
print('{0} {1}!'.format(row.greeting, row.greetee))
def complete(self):
return FalseLeverage command line tools with gluish.utils.shellout. shellout will
take a string argument and will format it according to the keyword arguments.
The {output} placeholder is special, since it will be automatically assigned
a path to a temporary file, if it is not specified as a keyword argument.
The return value of shellout is the path to the {output} file.
Spaces in the given string are normalized, unless preserve_whitespace=True is
passed. A literal curly brace can be inserted by {{ and }} respectively.
An exception is raised, whenever the commands exit with a non-zero return value.
Note: If you want to make sure an executable is available on you system before the task runs,
you can use a gluish.common.Executable task as requirement.
from gluish.common import Executable
from gluish.utils import shellout
import luigi
class GIFScreencast(DefaultTask):
""" Given a path to a screencast .mov, generate a GIF
which is funnier by definition. """
filename = luigi.Parameter(description='Path to a .mov screencast')
delay = luigi.IntParameter(default=3)
def requires(self):
return [Executable(name='ffmpg'),
Executable(name='gifsicle', message='http://www.lcdf.org/gifsicle/')]
def run(self):
output = shellout("""ffmpeg -i {infile} -s 600x400
-pix_fmt rgb24 -r 10 -f gif - |
gifsicle --optimize=3 --delay={delay} > {output} """,
infile=self.filename, delay=self.delay)
luigi.LocalTarget(output).move(self.output().path)
def output(self):
return luigi.LocalTarget(path=self.path())Sometimes the effective date for a task needs to be determined dynamically.
Consider for example a workflow involving an FTP server.
A data source is fetched from FTP, but it is not known, when updates are supplied. So the FTP server needs to be checked in regular intervals. Dependent tasks do not need to be updated as long as there is nothing new on the FTP server.
To map an arbitrary date to the closest date in the past, where an update
occured, you can use a gluish.parameter.ClosestDateParameter, which is just an ordinary
DateParameter but will invoke task.closest() behind the scene, to
figure out the effective date.
from gluish.parameter import ClosestDateParameter
import datetime
import luigi
class SimpleTask(DefaultTask):
""" Reuse DefaultTask from above """
date = ClosestDateParameter(default=datetime.date.today())
def closest(self):
# invoke dynamic checks here ...
# for simplicity, map this task to the last monday
return self.date - datetime.timedelta(days=self.date.weekday())
def run(self):
with self.output().open('w') as output:
output.write("It's just another manic Monday!")
def output(self):
return luigi.LocalTarget(path=self.path())A short, self contained example can be found in this gist.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent