Full Code of spotify/luigi for AI

gitextract_i5ice6bg/

├── .coveragerc
├── .github/
│   ├── CODEOWNERS
│   ├── ISSUE_TEMPLATE.md
│   ├── PULL_REQUEST_TEMPLATE.md
│   ├── stale.yml
│   └── workflows/
│       ├── codeql.yml
│       └── pythonbuild.yml
├── .gitignore
├── .readthedocs.yaml
├── CONTRIBUTING.rst
├── LICENSE
├── README.rst
├── RELEASE-PROCESS.rst
├── SECURITY.md
├── bin/
│   ├── luigi
│   └── luigid
├── catalog-info.yaml
├── codecov.yml
├── doc/
│   ├── .gitignore
│   ├── Makefile
│   ├── central_scheduler.rst
│   ├── conf.py
│   ├── configuration.rst
│   ├── design_and_limitations.rst
│   ├── example_top_artists.rst
│   ├── execution_model.rst
│   ├── index.rst
│   ├── logging.rst
│   ├── luigi_patterns.rst
│   ├── mypy.rst
│   ├── parameters.rst
│   ├── running_luigi.rst
│   ├── tasks.rst
│   └── workflows.rst
├── examples/
│   ├── __init__.py
│   ├── config.toml
│   ├── dynamic_requirements.py
│   ├── elasticsearch_index.py
│   ├── execution_summary_example.py
│   ├── foo.py
│   ├── foo_complex.py
│   ├── ftp_experiment_outputs.py
│   ├── hello_world.py
│   ├── kubernetes.py
│   ├── per_task_retry_policy.py
│   ├── pyspark_wc.py
│   ├── spark_als.py
│   ├── ssh_remote_execution.py
│   ├── terasort.py
│   ├── top_artists.py
│   ├── top_artists_spark.py
│   ├── wordcount.py
│   └── wordcount_hadoop.py
├── luigi/
│   ├── __init__.py
│   ├── __main__.py
│   ├── __version__.py
│   ├── batch_notifier.py
│   ├── cmdline.py
│   ├── cmdline_parser.py
│   ├── configuration/
│   │   ├── __init__.py
│   │   ├── base_parser.py
│   │   ├── cfg_parser.py
│   │   ├── core.py
│   │   └── toml_parser.py
│   ├── contrib/
│   │   ├── __init__.py
│   │   ├── azureblob.py
│   │   ├── batch.py
│   │   ├── beam_dataflow.py
│   │   ├── bigquery.py
│   │   ├── bigquery_avro.py
│   │   ├── datadog_metric.py
│   │   ├── dataproc.py
│   │   ├── docker_runner.py
│   │   ├── dropbox.py
│   │   ├── ecs.py
│   │   ├── esindex.py
│   │   ├── external_daily_snapshot.py
│   │   ├── external_program.py
│   │   ├── ftp.py
│   │   ├── gcp.py
│   │   ├── gcs.py
│   │   ├── hadoop.py
│   │   ├── hadoop_jar.py
│   │   ├── hdfs/
│   │   │   ├── __init__.py
│   │   │   ├── abstract_client.py
│   │   │   ├── clients.py
│   │   │   ├── config.py
│   │   │   ├── error.py
│   │   │   ├── format.py
│   │   │   ├── hadoopcli_clients.py
│   │   │   ├── target.py
│   │   │   └── webhdfs_client.py
│   │   ├── hive.py
│   │   ├── kubernetes.py
│   │   ├── lsf.py
│   │   ├── lsf_runner.py
│   │   ├── mongodb.py
│   │   ├── mssqldb.py
│   │   ├── mysqldb.py
│   │   ├── opener.py
│   │   ├── pai.py
│   │   ├── pig.py
│   │   ├── postgres.py
│   │   ├── presto.py
│   │   ├── prometheus_metric.py
│   │   ├── pyspark_runner.py
│   │   ├── rdbms.py
│   │   ├── redis_store.py
│   │   ├── redshift.py
│   │   ├── s3.py
│   │   ├── salesforce.py
│   │   ├── scalding.py
│   │   ├── sge.py
│   │   ├── sge_runner.py
│   │   ├── simulate.py
│   │   ├── spark.py
│   │   ├── sparkey.py
│   │   ├── sqla.py
│   │   ├── ssh.py
│   │   ├── target.py
│   │   └── webhdfs.py
│   ├── date_interval.py
│   ├── db_task_history.py
│   ├── event.py
│   ├── execution_summary.py
│   ├── format.py
│   ├── freezing.py
│   ├── interface.py
│   ├── local_target.py
│   ├── lock.py
│   ├── metrics.py
│   ├── mock.py
│   ├── mypy.py
│   ├── notifications.py
│   ├── parameter.py
│   ├── process.py
│   ├── py.typed
│   ├── retcodes.py
│   ├── rpc.py
│   ├── safe_extractor.py
│   ├── scheduler.py
│   ├── server.py
│   ├── setup_logging.py
│   ├── static/
│   │   └── visualiser/
│   │       ├── css/
│   │       │   ├── luigi.css
│   │       │   └── tipsy.css
│   │       ├── fonts/
│   │       │   └── FontAwesome.otf
│   │       ├── index.html
│   │       ├── js/
│   │       │   ├── graph.js
│   │       │   ├── luigi.js
│   │       │   ├── test/
│   │       │   │   └── graph_test.js
│   │       │   ├── tipsy.js
│   │       │   ├── util.js
│   │       │   └── visualiserApp.js
│   │       ├── lib/
│   │       │   ├── URI/
│   │       │   │   └── 1.18.2/
│   │       │   │       └── URI.js
│   │       │   ├── datatables/
│   │       │   │   └── images/
│   │       │   │       └── Sorting icons.psd
│   │       │   └── mustache.js
│   │       ├── mockdata/
│   │       │   ├── dep_graph
│   │       │   ├── fetch_error
│   │       │   └── task_list
│   │       └── test.html
│   ├── target.py
│   ├── task.py
│   ├── task_history.py
│   ├── task_register.py
│   ├── task_status.py
│   ├── templates/
│   │   ├── history.html
│   │   ├── layout.html
│   │   ├── menu.html
│   │   ├── recent.html
│   │   └── show.html
│   ├── tools/
│   │   ├── __init__.py
│   │   ├── deps.py
│   │   ├── deps_tree.py
│   │   ├── luigi_grep.py
│   │   └── range.py
│   ├── util.py
│   └── worker.py
├── pyproject.toml
├── scripts/
│   └── ci/
│       ├── conditional_tox.sh
│       ├── install_start_azurite.sh
│       ├── setup_hadoop_env.sh
│       └── stop_azurite.sh
├── test/
│   ├── _mysqldb_test.py
│   ├── _test_ftp.py
│   ├── auto_namespace_test/
│   │   ├── __init__.py
│   │   └── my_namespace_test.py
│   ├── batch_notifier_test.py
│   ├── choice_parameter_test.py
│   ├── clone_test.py
│   ├── cmdline_test.py
│   ├── config_env_test.py
│   ├── config_toml_test.py
│   ├── conftest.py
│   ├── contrib/
│   │   ├── __init__.py
│   │   ├── _webhdfs_test.py
│   │   ├── azureblob_test.py
│   │   ├── batch_test.py
│   │   ├── beam_dataflow_test.py
│   │   ├── bigquery_avro_test.py
│   │   ├── bigquery_gcloud_test.py
│   │   ├── bigquery_test.py
│   │   ├── cascading_test.py
│   │   ├── datadog_metric_test.py
│   │   ├── dataproc_test.py
│   │   ├── docker_runner_test.py
│   │   ├── dropbox_test.py
│   │   ├── ecs_test.py
│   │   ├── esindex_test.py
│   │   ├── external_daily_snapshot_test.py
│   │   ├── external_program_test.py
│   │   ├── gcs_test.py
│   │   ├── hadoop_jar_test.py
│   │   ├── hdfs/
│   │   │   └── webhdfs_client_test.py
│   │   ├── hdfs_test.py
│   │   ├── hive_test.py
│   │   ├── kubernetes_test.py
│   │   ├── lsf_test.py
│   │   ├── mongo_test.py
│   │   ├── mysqldb_test.py
│   │   ├── opener_test.py
│   │   ├── pai_test.py
│   │   ├── pig_test.py
│   │   ├── postgres_test.py
│   │   ├── postgres_with_server_test.py
│   │   ├── presto_test.py
│   │   ├── prometheus_metric_test.py
│   │   ├── rdbms_test.py
│   │   ├── redis_test.py
│   │   ├── redshift_test.py
│   │   ├── s3_test.py
│   │   ├── salesforce_test.py
│   │   ├── scalding_test.py
│   │   ├── sge_test.py
│   │   ├── spark_test.py
│   │   ├── sqla_test.py
│   │   ├── streaming_test.py
│   │   └── test_ssh.py
│   ├── create_packages_archive_root/
│   │   ├── module.py
│   │   └── package/
│   │       ├── __init__.py
│   │       ├── submodule.py
│   │       ├── submodule_with_absolute_import.py
│   │       ├── submodule_without_imports.py
│   │       └── subpackage/
│   │           ├── __init__.py
│   │           └── submodule.py
│   ├── custom_metrics_test.py
│   ├── customized_run_test.py
│   ├── date_interval_test.py
│   ├── date_parameter_test.py
│   ├── db_task_history_test.py
│   ├── decorator_test.py
│   ├── dict_parameter_test.py
│   ├── dynamic_import_test.py
│   ├── event_callbacks_test.py
│   ├── execution_summary_test.py
│   ├── factorial_test.py
│   ├── fib_test.py
│   ├── gcloud-credentials.json.enc
│   ├── hdfs_client_test.py
│   ├── helpers.py
│   ├── helpers_test.py
│   ├── import_test.py
│   ├── instance_test.py
│   ├── instance_wrap_test.py
│   ├── interface_test.py
│   ├── list_parameter_test.py
│   ├── local_target_test.py
│   ├── lock_test.py
│   ├── metrics_test.py
│   ├── mock_test.py
│   ├── most_common_test.py
│   ├── mypy_test.py
│   ├── notifications_test.py
│   ├── numerical_parameter_test.py
│   ├── optional_parameter_test.py
│   ├── other_module.py
│   ├── parameter_test.py
│   ├── priority_test.py
│   ├── range_test.py
│   ├── recursion_test.py
│   ├── remote_scheduler_test.py
│   ├── retcodes_test.py
│   ├── rpc_test.py
│   ├── runtests.py
│   ├── safe_extractor_test.py
│   ├── scheduler_api_test.py
│   ├── scheduler_message_test.py
│   ├── scheduler_parameter_visibilities_test.py
│   ├── scheduler_test.py
│   ├── scheduler_visualisation_test.py
│   ├── server_test.py
│   ├── set_task_name_test.py
│   ├── setup_logging_test.py
│   ├── simulate_test.py
│   ├── subtask_test.py
│   ├── target_test.py
│   ├── task_bulk_complete_test.py
│   ├── task_forwarded_attributes_test.py
│   ├── task_history_test.py
│   ├── task_progress_percentage_test.py
│   ├── task_register_test.py
│   ├── task_running_resources_test.py
│   ├── task_serialize_test.py
│   ├── task_status_message_test.py
│   ├── task_test.py
│   ├── test_sigpipe.py
│   ├── test_ssh.py
│   ├── testconfig/
│   │   ├── core-site.xml
│   │   ├── log4j.properties
│   │   ├── logging.cfg
│   │   ├── luigi.toml
│   │   ├── luigi_local.toml
│   │   ├── luigi_logging.toml
│   │   └── pyproject.toml
│   ├── util_previous_test.py
│   ├── util_test.py
│   ├── visible_parameters_test.py
│   ├── visualiser/
│   │   ├── __init__.py
│   │   ├── phantomjs_test.js
│   │   └── visualiser_test.py
│   ├── worker_external_task_test.py
│   ├── worker_keep_alive_test.py
│   ├── worker_multiprocess_test.py
│   ├── worker_parallel_scheduling_test.py
│   ├── worker_scheduler_com_test.py
│   ├── worker_task_process_test.py
│   ├── worker_task_test.py
│   ├── worker_test.py
│   └── wrap_test.py
└── tox.ini

SYMBOL INDEX (5364 symbols across 245 files)

FILE: doc/conf.py
  function parameter_repr (line 25) | def parameter_repr(self):
  function assertIn (line 39) | def assertIn(needle, haystack):

FILE: examples/dynamic_requirements.py
  class Configuration (line 25) | class Configuration(luigi.Task):
    method output (line 28) | def output(self):
    method run (line 38) | def run(self):
  class Data (line 47) | class Data(luigi.Task):
    method output (line 50) | def output(self):
    method run (line 60) | def run(self):
  class Dynamic (line 66) | class Dynamic(luigi.Task):
    method output (line 69) | def output(self):
    method run (line 79) | def run(self):

FILE: examples/elasticsearch_index.py
  class FakeDocuments (line 24) | class FakeDocuments(luigi.Task):
    method run (line 32) | def run(self):
    method output (line 49) | def output(self):
  class IndexDocuments (line 60) | class IndexDocuments(CopyToIndex):
    method requires (line 103) | def requires(self):

FILE: examples/execution_summary_example.py
  class MyExternal (line 53) | class MyExternal(luigi.ExternalTask):
    method complete (line 54) | def complete(self):
  class Boom (line 58) | class Boom(luigi.Task):
    method run (line 62) | def run(self):
    method requires (line 65) | def requires(self):
  class Foo (line 70) | class Foo(luigi.Task):
    method run (line 75) | def run(self):
    method requires (line 78) | def requires(self):
  class Bar (line 83) | class Bar(luigi.Task):
    method run (line 87) | def run(self):
    method output (line 90) | def output(self):
  class DateTask (line 94) | class DateTask(luigi.Task):
    method run (line 99) | def run(self):
    method requires (line 102) | def requires(self):
  class EntryPoint (line 107) | class EntryPoint(luigi.Task):
    method run (line 110) | def run(self):
    method requires (line 113) | def requires(self):

FILE: examples/foo.py
  class Foo (line 32) | class Foo(luigi.WrapperTask):
    method run (line 35) | def run(self):
    method requires (line 38) | def requires(self):
  class Bar (line 43) | class Bar(luigi.Task):
    method run (line 47) | def run(self):
    method output (line 51) | def output(self):

FILE: examples/foo_complex.py
  class Foo (line 37) | class Foo(luigi.Task):
    method run (line 40) | def run(self):
    method requires (line 43) | def requires(self):
  class Bar (line 50) | class Bar(luigi.Task):
    method run (line 55) | def run(self):
    method requires (line 59) | def requires(self):
    method output (line 68) | def output(self):

FILE: examples/ftp_experiment_outputs.py
  class ExperimentTask (line 28) | class ExperimentTask(luigi.ExternalTask):
    method output (line 34) | def output(self):
    method run (line 44) | def run(self):
  class ProcessingTask (line 55) | class ProcessingTask(luigi.Task):
    method requires (line 61) | def requires(self):
    method output (line 71) | def output(self):
    method run (line 81) | def run(self):

FILE: examples/hello_world.py
  class HelloWorldTask (line 14) | class HelloWorldTask(luigi.Task):
    method run (line 17) | def run(self):

FILE: examples/kubernetes.py
  class PerlPi (line 45) | class PerlPi(KubernetesJobTask):

FILE: examples/per_task_retry_policy.py
  class PerTaskRetryPolicy (line 56) | class PerTaskRetryPolicy(luigi.Task):
    method requires (line 66) | def requires(self):
    method output (line 69) | def output(self):
  class ErrorTask1 (line 73) | class ErrorTask1(luigi.Task):
    method run (line 82) | def run(self):
    method output (line 86) | def output(self):
  class ErrorTask2 (line 90) | class ErrorTask2(luigi.Task):
    method run (line 99) | def run(self):
    method output (line 103) | def output(self):
  class DynamicErrorTaskSubmitter (line 107) | class DynamicErrorTaskSubmitter(luigi.Task):
    method run (line 110) | def run(self):
    method output (line 117) | def output(self):
  class DynamicErrorTask1 (line 121) | class DynamicErrorTask1(luigi.Task):
    method run (line 130) | def run(self):
    method output (line 134) | def output(self):
  class SuccessTask1 (line 138) | class SuccessTask1(luigi.Task):
    method requires (line 139) | def requires(self):
    method run (line 142) | def run(self):
    method output (line 146) | def output(self):
  class SuccessSubTask1 (line 150) | class SuccessSubTask1(luigi.Task):
    method run (line 155) | def run(self):
    method output (line 159) | def output(self):

FILE: examples/pyspark_wc.py
  class InlinePySparkWordCount (line 22) | class InlinePySparkWordCount(PySparkTask):
    method input (line 42) | def input(self):
    method output (line 45) | def output(self):
    method main (line 48) | def main(self, sc, *args):
  class PySparkWordCount (line 54) | class PySparkWordCount(SparkSubmitTask):
    method app_options (line 81) | def app_options(self):
    method input (line 85) | def input(self):
    method output (line 88) | def output(self):

FILE: examples/spark_als.py
  class UserItemMatrix (line 26) | class UserItemMatrix(luigi.Task):
    method run (line 30) | def run(self):
    method output (line 48) | def output(self):
  class SparkALS (line 59) | class SparkALS(SparkSubmitTask):
    method app_options (line 84) | def app_options(self):
    method requires (line 88) | def requires(self):
    method output (line 98) | def output(self):

FILE: examples/ssh_remote_execution.py
  class CreateRemoteData (line 27) | class CreateRemoteData(luigi.Task):
    method output (line 33) | def output(self):
    method run (line 43) | def run(self):
  class ProcessRemoteData (line 48) | class ProcessRemoteData(luigi.Task):
    method requires (line 55) | def requires(self):
    method run (line 65) | def run(self):
    method output (line 78) | def output(self):

FILE: examples/terasort.py
  function hadoop_examples_jar (line 28) | def hadoop_examples_jar():
  class TeraGen (line 44) | class TeraGen(luigi.contrib.hadoop_jar.HadoopJarJobTask):
    method output (line 52) | def output(self):
    method jar (line 62) | def jar(self):
    method main (line 65) | def main(self):
    method args (line 68) | def args(self):
  class TeraSort (line 73) | class TeraSort(luigi.contrib.hadoop_jar.HadoopJarJobTask):
    method requires (line 81) | def requires(self):
    method output (line 91) | def output(self):
    method jar (line 101) | def jar(self):
    method main (line 104) | def main(self):
    method args (line 107) | def args(self):

FILE: examples/top_artists.py
  class ExternalStreams (line 28) | class ExternalStreams(luigi.ExternalTask):
    method output (line 38) | def output(self):
  class Streams (line 49) | class Streams(luigi.Task):
    method run (line 56) | def run(self):
    method output (line 64) | def output(self):
  class StreamsHdfs (line 75) | class StreamsHdfs(Streams):
    method output (line 83) | def output(self):
  class AggregateArtists (line 94) | class AggregateArtists(luigi.Task):
    method output (line 102) | def output(self):
    method requires (line 112) | def requires(self):
    method run (line 122) | def run(self):
  class AggregateArtistsSpark (line 136) | class AggregateArtistsSpark(luigi.contrib.spark.SparkSubmitTask):
    method output (line 158) | def output(self):
    method requires (line 168) | def requires(self):
    method app_options (line 178) | def app_options(self):
  class Top10Artists (line 184) | class Top10Artists(luigi.Task):
    method requires (line 194) | def requires(self):
    method output (line 208) | def output(self):
    method run (line 218) | def run(self):
    method _input_iterator (line 225) | def _input_iterator(self):
  class ArtistToplistToDatabase (line 232) | class ArtistToplistToDatabase(luigi.contrib.postgres.CopyToTable):
    method requires (line 254) | def requires(self):

FILE: examples/top_artists_spark.py
  function main (line 9) | def main(argv):

FILE: examples/wordcount.py
  class InputText (line 20) | class InputText(luigi.ExternalTask):
    method output (line 28) | def output(self):
  class WordCount (line 39) | class WordCount(luigi.Task):
    method requires (line 42) | def requires(self):
    method output (line 52) | def output(self):
    method run (line 62) | def run(self):

FILE: examples/wordcount_hadoop.py
  class InputText (line 28) | class InputText(luigi.ExternalTask):
    method output (line 37) | def output(self):
  class WordCount (line 48) | class WordCount(luigi.contrib.hadoop.JobTask):
    method requires (line 59) | def requires(self):
    method output (line 69) | def output(self):
    method mapper (line 79) | def mapper(self, line):
    method reducer (line 83) | def reducer(self, key, values):

FILE: luigi/batch_notifier.py
  class batch_email (line 16) | class batch_email(luigi.task.Config):
  class ExplQueue (line 35) | class ExplQueue(collections.OrderedDict):
    method __init__ (line 36) | def __init__(self, num_items):
    method enqueue (line 40) | def enqueue(self, item):
  function _fail_queue (line 47) | def _fail_queue(num_messages):
  function _plural_format (line 51) | def _plural_format(template, number, plural="s"):
  class BatchNotifier (line 57) | class BatchNotifier:
    method __init__ (line 58) | def __init__(self, **kwargs):
    method _update_next_send (line 72) | def _update_next_send(self):
    method _key (line 75) | def _key(self, task_name, family, unbatched_args):
    method _format_expl (line 86) | def _format_expl(self, expl):
    method _expl_body (line 93) | def _expl_body(self, expls):
    method _format_task (line 99) | def _format_task(self, task_tuple):
    method _format_tasks (line 109) | def _format_tasks(self, tasks):
    method _owners (line 116) | def _owners(self, owners):
    method add_failure (line 119) | def add_failure(self, task_name, family, unbatched_args, expl, owners):
    method add_disable (line 125) | def add_disable(self, task_name, family, unbatched_args, owners):
    method add_scheduling_fail (line 131) | def add_scheduling_fail(self, task_name, family, unbatched_args, expl,...
    method _task_expl_groups (line 138) | def _task_expl_groups(self, expls):
    method _expls_key (line 147) | def _expls_key(self, expls_tuple):
    method _expl_key (line 154) | def _expl_key(self, expl):
    method _email_body (line 157) | def _email_body(self, fail_counts, disable_counts, scheduling_counts, ...
    method _send_email (line 172) | def _send_email(self, fail_counts, disable_counts, scheduling_counts, ...
    method send_email (line 188) | def send_email(self):
    method update (line 205) | def update(self):

FILE: luigi/cmdline.py
  function luigi_run (line 8) | def luigi_run(argv=sys.argv[1:]):
  function luigid (line 12) | def luigid(argv=sys.argv[1:]):

FILE: luigi/cmdline_parser.py
  class CmdlineParser (line 29) | class CmdlineParser:
    method get_instance (line 40) | def get_instance(cls):
    method global_instance (line 46) | def global_instance(cls, cmdline_args, allow_override=False):
    method __init__ (line 61) | def __init__(self, cmdline_args):
    method _build_parser (line 82) | def _build_parser(root_task=None, help_all=False):
    method get_task_obj (line 106) | def get_task_obj(self):
    method _get_task_cls (line 112) | def _get_task_cls(self):
    method _get_task_kwargs (line 118) | def _get_task_kwargs(self):
    method _attempt_load_module (line 132) | def _attempt_load_module(known_args):
    method _possibly_exit_with_help (line 141) | def _possibly_exit_with_help(parser, known_args):

FILE: luigi/configuration/base_parser.py
  class BaseParser (line 23) | class BaseParser:
    method instance (line 25) | def instance(cls, *args, **kwargs):
    method add_config_path (line 35) | def add_config_path(cls, path):
    method reload (line 40) | def reload(cls):

FILE: luigi/configuration/cfg_parser.py
  class InterpolationMissingEnvvarError (line 40) | class InterpolationMissingEnvvarError(InterpolationError):
    method __init__ (line 45) | def __init__(self, option, section, value, envvar):
  class EnvironmentInterpolation (line 50) | class EnvironmentInterpolation(Interpolation):
    method before_get (line 58) | def before_get(self, parser, section, option, value, defaults):
    method _interpolate_env (line 61) | def _interpolate_env(self, option, section, value):
  class CombinedInterpolation (line 81) | class CombinedInterpolation(Interpolation):
    method __init__ (line 88) | def __init__(self, interpolations):
    method before_get (line 91) | def before_get(self, parser, section, option, value, defaults):
    method before_read (line 96) | def before_read(self, parser, section, option, value):
    method before_set (line 101) | def before_set(self, parser, section, option, value):
    method before_write (line 106) | def before_write(self, parser, section, option, value):
  class LuigiConfigParser (line 112) | class LuigiConfigParser(BaseParser, ConfigParser):
    method reload (line 126) | def reload(cls):
    method _get_with_default (line 137) | def _get_with_default(self, method, section, option, default, expected...
    method has_option (line 164) | def has_option(self, section, option):
    method get (line 185) | def get(self, section, option, default=NO_DEFAULT, **kwargs):
    method getboolean (line 188) | def getboolean(self, section, option, default=NO_DEFAULT):
    method getint (line 191) | def getint(self, section, option, default=NO_DEFAULT):
    method getfloat (line 194) | def getfloat(self, section, option, default=NO_DEFAULT):
    method getintdict (line 197) | def getintdict(self, section):
    method set (line 204) | def set(self, section, option, value=None):

FILE: luigi/configuration/core.py
  function _get_default_parser (line 37) | def _get_default_parser():
  function _check_parser (line 45) | def _check_parser(parser_class, parser):
  function get_config (line 51) | def get_config(parser=None):
  function add_config_path (line 60) | def add_config_path(path):

FILE: luigi/configuration/toml_parser.py
  class LuigiTomlParser (line 32) | class LuigiTomlParser(BaseParser, ConfigParser):
    method _update_data (line 43) | def _update_data(data, new_data):
    method read (line 54) | def read(self, config_paths):
    method get (line 68) | def get(self, section, option, default=NO_DEFAULT, **kwargs):
    method getboolean (line 76) | def getboolean(self, section, option, default=NO_DEFAULT):
    method getint (line 79) | def getint(self, section, option, default=NO_DEFAULT):
    method getfloat (line 82) | def getfloat(self, section, option, default=NO_DEFAULT):
    method getintdict (line 85) | def getintdict(self, section):
    method set (line 88) | def set(self, section, option, value=None):
    method has_option (line 93) | def has_option(self, section, option):
    method __getitem__ (line 96) | def __getitem__(self, name):

FILE: luigi/contrib/azureblob.py
  class AzureBlobClient (line 31) | class AzureBlobClient(FileSystem):
    method __init__ (line 45) | def __init__(self, account_name=None, account_key=None, sas_token=None...
    method connection (line 79) | def connection(self):
    method container_client (line 87) | def container_client(self, container_name):
    method blob_client (line 90) | def blob_client(self, container_name, blob_name):
    method upload (line 94) | def upload(self, tmp_path, container, blob, **kwargs):
    method download_as_bytes (line 108) | def download_as_bytes(self, container, blob, bytes_to_read=None):
    method download_as_file (line 114) | def download_as_file(self, container, blob, location):
    method create_container (line 122) | def create_container(self, container_name):
    method delete_container (line 126) | def delete_container(self, container_name):
    method exists (line 131) | def exists(self, path):
    method remove (line 138) | def remove(self, path, recursive=True, skip_trash=True):
    method mkdir (line 148) | def mkdir(self, path, parents=True, raise_if_exists=False):
    method isdir (line 153) | def isdir(self, path):
    method move (line 161) | def move(self, path, dest):
    method copy (line 168) | def copy(self, path, dest):
    method rename_dont_move (line 189) | def rename_dont_move(self, path, dest):
    method splitfilepath (line 193) | def splitfilepath(filepath):
  class ReadableAzureBlobFile (line 201) | class ReadableAzureBlobFile:
    method __init__ (line 202) | def __init__(self, container, blob, client, download_when_reading, **k...
    method read (line 212) | def read(self, n=None):
    method __enter__ (line 215) | def __enter__(self):
    method __exit__ (line 223) | def __exit__(self, exc_type, exc, traceback):
    method __del__ (line 226) | def __del__(self):
    method close (line 231) | def close(self):
    method readable (line 237) | def readable(self):
    method writable (line 240) | def writable(self):
    method seekable (line 243) | def seekable(self):
    method seek (line 246) | def seek(self, offset, whence=None):
  class AtomicAzureBlobFile (line 250) | class AtomicAzureBlobFile(AtomicLocalFile):
    method __init__ (line 251) | def __init__(self, container, blob, client, **kwargs):
    method move_to_final_destination (line 258) | def move_to_final_destination(self):
  class AzureBlobTarget (line 262) | class AzureBlobTarget(FileSystemTarget):
    method __init__ (line 267) | def __init__(self, container, blob, client=None, format=None, download...
    method fs (line 297) | def fs(self):
    method open (line 303) | def open(self, mode):

FILE: luigi/contrib/batch.py
  class BatchJobException (line 78) | class BatchJobException(Exception):
  function _random_id (line 85) | def _random_id():
  class BatchClient (line 89) | class BatchClient:
    method __init__ (line 90) | def __init__(self, poll_time=POLL_TIME):
    method get_active_queue (line 96) | def get_active_queue(self):
    method get_job_id_from_name (line 107) | def get_job_id_from_name(self, job_name):
    method get_job_status (line 114) | def get_job_status(self, job_id):
    method get_logs (line 131) | def get_logs(self, log_stream_name, get_last=50):
    method submit_job (line 137) | def submit_job(self, job_definition, parameters, job_name=None, queue=...
    method wait_on_job (line 144) | def wait_on_job(self, job_id):
    method register_job_definition (line 165) | def register_job_definition(self, json_fpath):
  class BatchTask (line 177) | class BatchTask(luigi.Task):
    method run (line 196) | def run(self):
    method parameters (line 202) | def parameters(self):

FILE: luigi/contrib/beam_dataflow.py
  class DataflowParamKeys (line 33) | class DataflowParamKeys(metaclass=abc.ABCMeta):
    method runner (line 43) | def runner(self):
    method project (line 48) | def project(self):
    method zone (line 53) | def zone(self):
    method region (line 58) | def region(self):
    method staging_location (line 63) | def staging_location(self):
    method temp_location (line 68) | def temp_location(self):
    method gcp_temp_location (line 73) | def gcp_temp_location(self):
    method num_workers (line 78) | def num_workers(self):
    method autoscaling_algorithm (line 83) | def autoscaling_algorithm(self):
    method max_num_workers (line 88) | def max_num_workers(self):
    method disk_size_gb (line 93) | def disk_size_gb(self):
    method worker_machine_type (line 98) | def worker_machine_type(self):
    method worker_disk_type (line 103) | def worker_disk_type(self):
    method job_name (line 108) | def job_name(self):
    method service_account (line 113) | def service_account(self):
    method network (line 118) | def network(self):
    method subnetwork (line 123) | def subnetwork(self):
    method labels (line 128) | def labels(self):
  class _CmdLineRunner (line 132) | class _CmdLineRunner:
    method run (line 141) | def run(cmd, task=None):
  class BeamDataflowJobTask (line 158) | class BeamDataflowJobTask(MixinNaiveBulkComplete, luigi.Task, metaclass=...
    method __init__ (line 232) | def __init__(self):
    method dataflow_executable (line 238) | def dataflow_executable(self):
    method args (line 247) | def args(self):
    method before_run (line 256) | def before_run(self):
    method on_successful_run (line 263) | def on_successful_run(self):
    method validate_output (line 270) | def validate_output(self):
    method file_pattern (line 278) | def file_pattern(self):
    method on_successful_output_validation (line 289) | def on_successful_output_validation(self):
    method cleanup_on_error (line 296) | def cleanup_on_error(self, error):
    method run (line 303) | def run(self):
    method _mk_cmd_line (line 325) | def _mk_cmd_line(self):
    method _get_runner (line 334) | def _get_runner(self):
    method _get_dataflow_args (line 343) | def _get_dataflow_args(self):
    method _format_input_args (line 388) | def _format_input_args(self):
    method _format_output_args (line 452) | def _format_output_args(self):
    method get_target_path (line 478) | def get_target_path(target):

FILE: luigi/contrib/bigquery.py
  function is_error_5xx (line 42) | def is_error_5xx(err):
  class CreateDisposition (line 55) | class CreateDisposition:
  class WriteDisposition (line 60) | class WriteDisposition:
  class QueryMode (line 66) | class QueryMode:
  class SourceFormat (line 71) | class SourceFormat:
  class FieldDelimiter (line 79) | class FieldDelimiter:
  class PrintHeader (line 96) | class PrintHeader:
  class DestinationFormat (line 101) | class DestinationFormat:
  class Compression (line 107) | class Compression:
  class Encoding (line 112) | class Encoding:
  class BQTable (line 126) | class BQTable(collections.namedtuple("BQTable", "project_id dataset_id t...
    method dataset (line 128) | def dataset(self):
    method uri (line 132) | def uri(self):
  class BigQueryClient (line 136) | class BigQueryClient:
    method __init__ (line 144) | def __init__(self, oauth_credentials=None, descriptor="", http_=None):
    method _initialise_client (line 153) | def _initialise_client(self):
    method dataset_exists (line 162) | def dataset_exists(self, dataset):
    method table_exists (line 189) | def table_exists(self, table):
    method make_dataset (line 207) | def make_dataset(self, dataset, raise_if_exists=False, body=None):
    method delete_dataset (line 233) | def delete_dataset(self, dataset, delete_nonempty=True):
    method delete_table (line 246) | def delete_table(self, table):
    method list_datasets (line 258) | def list_datasets(self, project_id):
    method list_tables (line 278) | def list_tables(self, dataset):
    method get_view (line 298) | def get_view(self, table):
    method update_view (line 316) | def update_view(self, table, view):
    method run_job (line 335) | def run_job(self, project_id, body, dataset=None):
    method copy (line 364) | def copy(self, source_table, dest_table, create_disposition=CreateDisp...
  class BigQueryTarget (line 399) | class BigQueryTarget(luigi.target.Target):
    method __init__ (line 400) | def __init__(self, project_id, dataset_id, table_id, client=None, loca...
    method from_bqtable (line 405) | def from_bqtable(cls, table, client=None):
    method exists (line 413) | def exists(self):
    method __str__ (line 416) | def __str__(self):
  class MixinBigQueryBulkComplete (line 420) | class MixinBigQueryBulkComplete:
    method bulk_complete (line 430) | def bulk_complete(cls, parameter_tuples):
  class BigQueryLoadTask (line 452) | class BigQueryLoadTask(MixinBigQueryBulkComplete, luigi.Task):
    method source_format (line 456) | def source_format(self):
    method encoding (line 461) | def encoding(self):
    method write_disposition (line 466) | def write_disposition(self):
    method schema (line 473) | def schema(self):
    method max_bad_records (line 480) | def max_bad_records(self):
    method field_delimiter (line 487) | def field_delimiter(self):
    method source_uris (line 491) | def source_uris(self):
    method skip_leading_rows (line 498) | def skip_leading_rows(self):
    method allow_jagged_rows (line 505) | def allow_jagged_rows(self):
    method ignore_unknown_values (line 514) | def ignore_unknown_values(self):
    method allow_quoted_new_lines (line 527) | def allow_quoted_new_lines(self):
    method configure_job (line 531) | def configure_job(self, configuration):
    method run (line 541) | def run(self):
  class BigQueryRunQueryTask (line 584) | class BigQueryRunQueryTask(MixinBigQueryBulkComplete, luigi.Task):
    method write_disposition (line 586) | def write_disposition(self):
    method create_disposition (line 593) | def create_disposition(self):
    method flatten_results (line 598) | def flatten_results(self):
    method query (line 604) | def query(self):
    method query_mode (line 609) | def query_mode(self):
    method udf_resource_uris (line 614) | def udf_resource_uris(self):
    method use_legacy_sql (line 619) | def use_legacy_sql(self):
    method configure_job (line 623) | def configure_job(self, configuration):
    method run (line 633) | def run(self):
  class BigQueryCreateViewTask (line 671) | class BigQueryCreateViewTask(luigi.Task):
    method view (line 682) | def view(self):
    method complete (line 686) | def complete(self):
    method run (line 696) | def run(self):
  class ExternalBigQueryTask (line 710) | class ExternalBigQueryTask(MixinBigQueryBulkComplete, luigi.ExternalTask):
  class BigQueryExtractTask (line 718) | class BigQueryExtractTask(luigi.Task):
    method destination_uris (line 728) | def destination_uris(self):
    method print_header (line 742) | def print_header(self):
    method field_delimiter (line 747) | def field_delimiter(self):
    method destination_format (line 755) | def destination_format(self):
    method compression (line 762) | def compression(self):
    method configure_job (line 766) | def configure_job(self, configuration):
    method run (line 776) | def run(self):
  class BigQueryExecutionError (line 821) | class BigQueryExecutionError(Exception):
    method __init__ (line 822) | def __init__(self, job_id, error_message) -> None:

FILE: luigi/contrib/bigquery_avro.py
  class BigQueryLoadAvro (line 18) | class BigQueryLoadAvro(BigQueryLoadTask):
    method _avro_uri (line 33) | def _avro_uri(self, target):
    method source_uris (line 37) | def source_uris(self):
    method _get_input_schema (line 40) | def _get_input_schema(self):
    method _get_writer_schema (line 78) | def _get_writer_schema(datum_reader):
    method _set_output_doc (line 89) | def _set_output_doc(self, avro_schema):
    method run (line 99) | def run(self):

FILE: luigi/contrib/datadog_metric.py
  class datadog (line 15) | class datadog(Config):
  class DatadogMetricsCollector (line 25) | class DatadogMetricsCollector(MetricsCollector):
    method __init__ (line 26) | def __init__(self, *args, **kwargs):
    method handle_task_started (line 31) | def handle_task_started(self, task):
    method handle_task_failed (line 41) | def handle_task_failed(self, task):
    method handle_task_disabled (line 51) | def handle_task_disabled(self, task, config):
    method handle_task_done (line 68) | def handle_task_done(self, task):
    method _send_event (line 85) | def _send_event(self, **params):
    method _send_gauge (line 90) | def _send_gauge(self, metric_name, value, tags=[]):
    method _send_increment (line 96) | def _send_increment(self, metric_name, value=1, tags=[]):
    method _format_task_params_to_tags (line 102) | def _format_task_params_to_tags(self, task):
    method default_tags (line 110) | def default_tags(self):

FILE: luigi/contrib/dataproc.py
  function get_dataproc_client (line 29) | def get_dataproc_client():
  function set_dataproc_client (line 33) | def set_dataproc_client(client):
  class _DataprocBaseTask (line 38) | class _DataprocBaseTask(luigi.Task):
  class DataprocBaseTask (line 46) | class DataprocBaseTask(_DataprocBaseTask):
    method submit_job (line 56) | def submit_job(self, job_config):
    method submit_spark_job (line 63) | def submit_spark_job(self, jars, main_class, job_args=None):
    method submit_pyspark_job (line 76) | def submit_pyspark_job(self, job_file, extra_files=list(), job_args=No...
    method wait_for_job (line 92) | def wait_for_job(self):
  class DataprocSparkTask (line 112) | class DataprocSparkTask(DataprocBaseTask):
    method run (line 121) | def run(self):
  class DataprocPysparkTask (line 128) | class DataprocPysparkTask(DataprocBaseTask):
    method run (line 137) | def run(self):
  class CreateDataprocClusterTask (line 146) | class CreateDataprocClusterTask(_DataprocBaseTask):
    method _get_cluster_status (line 160) | def _get_cluster_status(self):
    method complete (line 169) | def complete(self):
    method run (line 179) | def run(self):
  class DeleteDataprocClusterTask (line 221) | class DeleteDataprocClusterTask(_DataprocBaseTask):
    method _get_cluster_status (line 230) | def _get_cluster_status(self):
    method complete (line 245) | def complete(self):
    method run (line 248) | def run(self):

FILE: luigi/contrib/docker_runner.py
  class DockerTask (line 67) | class DockerTask(luigi.Task):
    method image (line 69) | def image(self):
    method command (line 73) | def command(self):
    method name (line 77) | def name(self):
    method host_config_options (line 81) | def host_config_options(self):
    method container_options (line 91) | def container_options(self):
    method environment (line 101) | def environment(self):
    method container_tmp_dir (line 105) | def container_tmp_dir(self):
    method binds (line 109) | def binds(self):
    method network_mode (line 118) | def network_mode(self):
    method docker_url (line 122) | def docker_url(self):
    method auto_remove (line 126) | def auto_remove(self):
    method force_pull (line 130) | def force_pull(self):
    method mount_tmp (line 134) | def mount_tmp(self):
    method __init__ (line 137) | def __init__(self, *args, **kwargs):
    method run (line 183) | def run(self):

FILE: luigi/contrib/dropbox.py
  function accept_trailing_slash_in_existing_dirpaths (line 42) | def accept_trailing_slash_in_existing_dirpaths(func):
  function accept_trailing_slash (line 57) | def accept_trailing_slash(func):
  class DropboxClient (line 67) | class DropboxClient(FileSystem):
    method __init__ (line 72) | def __init__(self, token, user_agent="Luigi", root_namespace_id=None):
    method exists (line 92) | def exists(self, path):
    method remove (line 109) | def remove(self, path, recursive=True, skip_trash=True):
    method mkdir (line 116) | def mkdir(self, path, parents=True, raise_if_exists=False):
    method isdir (line 128) | def isdir(self, path):
    method listdir (line 141) | def listdir(self, path, **kwargs):
    method move (line 151) | def move(self, path, dest):
    method copy (line 155) | def copy(self, path, dest):
    method download_as_bytes (line 158) | def download_as_bytes(self, path):
    method upload (line 162) | def upload(self, tmp_path, dest_path):
    method _exists_and_is_dir (line 182) | def _exists_and_is_dir(self, path):
  class ReadableDropboxFile (line 197) | class ReadableDropboxFile:
    method __init__ (line 198) | def __init__(self, path, client):
    method read (line 212) | def read(self):
    method __enter__ (line 215) | def __enter__(self):
    method __exit__ (line 218) | def __exit__(self, exc_type, exc, traceback):
    method __del__ (line 221) | def __del__(self):
    method close (line 226) | def close(self):
    method readable (line 229) | def readable(self):
    method writable (line 232) | def writable(self):
    method seekable (line 235) | def seekable(self):
  class AtomicWritableDropboxFile (line 239) | class AtomicWritableDropboxFile(AtomicLocalFile):
    method __init__ (line 240) | def __init__(self, path, client):
    method move_to_final_destination (line 251) | def move_to_final_destination(self):
  class DropboxTarget (line 258) | class DropboxTarget(FileSystemTarget):
    method __init__ (line 263) | def __init__(self, path, token, format=None, user_agent="Luigi", root_...
    method __str__ (line 305) | def __str__(self):
    method fs (line 309) | def fs(self):
    method temporary_path (line 313) | def temporary_path(self):
    method open (line 322) | def open(self, mode):

FILE: luigi/contrib/ecs.py
  function _get_task_statuses (line 71) | def _get_task_statuses(task_ids, cluster):
  function _track_tasks (line 90) | def _track_tasks(task_ids, cluster):
  class ECSTask (line 101) | class ECSTask(luigi.Task):
    method ecs_task_ids (line 142) | def ecs_task_ids(self):
    method command (line 148) | def command(self):
    method update_container_overrides_command (line 170) | def update_container_overrides_command(container_overrides, command):
    method combined_overrides (line 186) | def combined_overrides(self):
    method run_task_kwargs (line 204) | def run_task_kwargs(self):
    method run (line 243) | def run(self):

FILE: luigi/contrib/esindex.py
  class ElasticsearchTarget (line 107) | class ElasticsearchTarget(luigi.Target):
    method __init__ (line 113) | def __init__(self, host, port, index, doc_type, update_id, marker_inde...
    method marker_index_document_id (line 154) | def marker_index_document_id(self):
    method touch (line 161) | def touch(self):
    method exists (line 179) | def exists(self):
    method create_marker_index (line 192) | def create_marker_index(self):
    method ensure_hist_size (line 199) | def ensure_hist_size(self):
  class CopyToIndex (line 217) | class CopyToIndex(luigi.Task):
    method host (line 246) | def host(self):
    method port (line 253) | def port(self):
    method http_auth (line 260) | def http_auth(self):
    method index (line 269) | def index(self):
    method doc_type (line 278) | def doc_type(self):
    method mapping (line 285) | def mapping(self):
    method settings (line 292) | def settings(self):
    method chunk_size (line 299) | def chunk_size(self):
    method raise_on_error (line 306) | def raise_on_error(self):
    method purge_existing_index (line 313) | def purge_existing_index(self):
    method marker_index_hist_size (line 320) | def marker_index_hist_size(self):
    method timeout (line 327) | def timeout(self):
    method extra_elasticsearch_args (line 334) | def extra_elasticsearch_args(self):
    method docs (line 340) | def docs(self):
    method _docs (line 352) | def _docs(self):
    method _init_connection (line 375) | def _init_connection(self):
    method create_index (line 385) | def create_index(self):
    method delete_index (line 395) | def delete_index(self):
    method update_id (line 403) | def update_id(self):
    method output (line 409) | def output(self):
    method run (line 427) | def run(self):

FILE: luigi/contrib/external_daily_snapshot.py
  class ExternalDailySnapshot (line 29) | class ExternalDailySnapshot(luigi.ExternalTask):
    method latest (line 55) | def latest(cls, *args, **kwargs):
    method __latest (line 69) | def __latest(cls, date, lookback, args, kwargs):

FILE: luigi/contrib/external_program.py
  class ExternalProgramTask (line 49) | class ExternalProgramTask(luigi.Task):
    method program_args (line 100) | def program_args(self):
    method program_environment (line 108) | def program_environment(self):
    method always_log_stderr (line 118) | def always_log_stderr(self):
    method _clean_output_file (line 126) | def _clean_output_file(self, file_object):
    method build_tracking_url (line 130) | def build_tracking_url(self, logs_output):
    method run (line 138) | def run(self):
    method _proc_with_tracking_url_context (line 179) | def _proc_with_tracking_url_context(self, proc_args, proc_kwargs):
  class ExternalProgramRunContext (line 216) | class ExternalProgramRunContext:
    method __init__ (line 217) | def __init__(self, proc):
    method __enter__ (line 220) | def __enter__(self):
    method __exit__ (line 225) | def __exit__(self, exc_type, exc_val, exc_tb):
    method kill_job (line 230) | def kill_job(self, captured_signal=None, stack_frame=None):
  class ExternalProgramRunError (line 237) | class ExternalProgramRunError(RuntimeError):
    method __init__ (line 238) | def __init__(self, message, args, env=None, stdout=None, stderr=None):
    method __str__ (line 246) | def __str__(self):
  class ExternalPythonProgramTask (line 260) | class ExternalPythonProgramTask(ExternalProgramTask):
    method program_environment (line 280) | def program_environment(self):

FILE: luigi/contrib/ftp.py
  class RemoteFileSystem (line 45) | class RemoteFileSystem(luigi.target.FileSystem):
    method __init__ (line 46) | def __init__(self, host, username=None, password=None, port=None, tls=...
    method _connect (line 63) | def _connect(self):
    method _sftp_connect (line 72) | def _sftp_connect(self):
    method _ftp_connect (line 80) | def _ftp_connect(self):
    method _close (line 90) | def _close(self):
    method _sftp_close (line 99) | def _sftp_close(self):
    method _ftp_close (line 102) | def _ftp_close(self):
    method exists (line 105) | def exists(self, path, mtime=None):
    method _sftp_exists (line 124) | def _sftp_exists(self, path, mtime):
    method _ftp_exists (line 132) | def _ftp_exists(self, path, mtime):
    method remove (line 147) | def remove(self, path, recursive=True):
    method _sftp_remove (line 166) | def _sftp_remove(self, path, recursive):
    method _ftp_remove (line 182) | def _ftp_remove(self, path, recursive):
    method _rm_recursive (line 193) | def _rm_recursive(self, ftp, path):
    method put (line 234) | def put(self, local_path, path, atomic=True):
    method _sftp_put (line 247) | def _sftp_put(self, local_path, path, atomic):
    method _ftp_put (line 262) | def _ftp_put(self, local_path, path, atomic):
    method get (line 287) | def get(self, path, local_path):
    method _sftp_get (line 310) | def _sftp_get(self, path, tmp_local_path):
    method _ftp_get (line 313) | def _ftp_get(self, path, tmp_local_path):
    method listdir (line 316) | def listdir(self, path="."):
    method _sftp_listdir (line 331) | def _sftp_listdir(self, path):
    method _ftp_listdir (line 334) | def _ftp_listdir(self, path):
  class AtomicFtpFile (line 338) | class AtomicFtpFile(luigi.target.AtomicLocalFile):
    method __init__ (line 345) | def __init__(self, fs, path):
    method move_to_final_destination (line 355) | def move_to_final_destination(self):
    method fs (line 359) | def fs(self):
  class RemoteTarget (line 363) | class RemoteTarget(luigi.target.FileSystemTarget):
    method __init__ (line 371) | def __init__(
    method fs (line 386) | def fs(self):
    method open (line 389) | def open(self, mode):
    method exists (line 423) | def exists(self):
    method put (line 426) | def put(self, local_path, atomic=True):
    method get (line 429) | def get(self, local_path):

FILE: luigi/contrib/gcp.py
  function get_authenticate_kwargs (line 19) | def get_authenticate_kwargs(oauth_credentials=None, http_=None):

FILE: luigi/contrib/gcs.py
  function is_error_5xx (line 68) | def is_error_5xx(err):
  function _wait_for_consistency (line 81) | def _wait_for_consistency(checker):
  class InvalidDeleteException (line 96) | class InvalidDeleteException(luigi.target.FileSystemException):
  class GCSClient (line 100) | class GCSClient(luigi.target.FileSystem):
    method __init__ (line 124) | def __init__(self, oauth_credentials=None, descriptor="", http_=None, ...
    method _path_to_bucket_and_key (line 137) | def _path_to_bucket_and_key(self, path):
    method _is_root (line 143) | def _is_root(self, key):
    method _add_path_delimiter (line 146) | def _add_path_delimiter(self, key):
    method _obj_exists (line 150) | def _obj_exists(self, bucket, obj):
    method _list_iter (line 160) | def _list_iter(self, bucket, prefix):
    method _do_put (line 175) | def _do_put(self, media, dest_path):
    method exists (line 191) | def exists(self, path):
    method isdir (line 198) | def isdir(self, path):
    method remove (line 217) | def remove(self, path, recursive=True):
    method put (line 242) | def put(self, filename, dest_path, mimetype=None, chunksize=None):
    method _forward_args_to_put (line 251) | def _forward_args_to_put(self, kwargs):
    method put_multiple (line 254) | def put_multiple(self, filepaths, remote_directory, mimetype=None, chu...
    method put_string (line 278) | def put_string(self, contents, dest_path, mimetype=None):
    method mkdir (line 286) | def mkdir(self, path, parents=True, raise_if_exists=False):
    method copy (line 297) | def copy(self, source_path, destination_path):
    method rename (line 322) | def rename(self, *args, **kwargs):
    method move (line 328) | def move(self, source_path, destination_path):
    method listdir (line 335) | def listdir(self, path):
    method list_wildcard (line 350) | def list_wildcard(self, wildcard_path):
    method download (line 372) | def download(self, path, chunksize=None, chunk_callback=lambda _: False):
  class _DeleteOnCloseFile (line 401) | class _DeleteOnCloseFile(io.FileIO):
    method close (line 402) | def close(self):
    method readable (line 411) | def readable(self):
    method writable (line 414) | def writable(self):
    method seekable (line 417) | def seekable(self):
  class AtomicGCSFile (line 421) | class AtomicGCSFile(luigi.target.AtomicLocalFile):
    method __init__ (line 426) | def __init__(self, path, gcs_client):
    method move_to_final_destination (line 430) | def move_to_final_destination(self):
  class GCSTarget (line 434) | class GCSTarget(luigi.target.FileSystemTarget):
    method __init__ (line 437) | def __init__(self, path, format=None, client=None):
    method open (line 445) | def open(self, mode="r"):
  class GCSFlagTarget (line 454) | class GCSFlagTarget(GCSTarget):
    method __init__ (line 476) | def __init__(self, path, format=None, client=None, flag="_SUCCESS"):
    method exists (line 497) | def exists(self):

FILE: luigi/contrib/hadoop.py
  class hadoop (line 65) | class hadoop(Config):
  function attach (line 72) | def attach(*packages):
  function dereference (line 80) | def dereference(f):
  function get_extra_files (line 88) | def get_extra_files(extra_files):
  function create_packages_archive (line 112) | def create_packages_archive(packages, filename):
  function flatten (line 181) | def flatten(sequence):
  class HadoopRunContext (line 200) | class HadoopRunContext:
    method __init__ (line 201) | def __init__(self):
    method __enter__ (line 205) | def __enter__(self):
    method kill_job (line 210) | def kill_job(self, captured_signal=None, stack_frame=None):
    method __exit__ (line 221) | def __exit__(self, exc_type, exc_val, exc_tb):
  class HadoopJobError (line 227) | class HadoopJobError(RuntimeError):
    method __init__ (line 228) | def __init__(self, message, out=None, err=None):
    method __str__ (line 234) | def __str__(self):
  function run_and_track_hadoop_job (line 238) | def run_and_track_hadoop_job(arglist, tracking_url_callback=None, env=No...
  function fetch_task_failures (line 340) | def fetch_task_failures(tracking_url):
  class JobRunner (line 379) | class JobRunner:
  class HadoopJobRunner (line 383) | class HadoopJobRunner(JobRunner):
    method __init__ (line 390) | def __init__(
    method run_job (line 418) | def run_job(self, job, tracking_url_callback=None):
    method finish (line 571) | def finish(self):
    method __del__ (line 577) | def __del__(self):
  class DefaultHadoopJobRunner (line 581) | class DefaultHadoopJobRunner(HadoopJobRunner):
    method __init__ (line 586) | def __init__(self):
  class LocalJobRunner (line 593) | class LocalJobRunner(JobRunner):
    method __init__ (line 602) | def __init__(self, samplelines=None):
    method sample (line 605) | def sample(self, input_stream, n, output):
    method group (line 611) | def group(self, input_stream):
    method run_job (line 623) | def run_job(self, job):
  class BaseHadoopJobTask (line 657) | class BaseHadoopJobTask(luigi.Task):
    method _get_pool (line 672) | def _get_pool(self):
    method job_runner (line 680) | def job_runner(self):
    method jobconfs (line 683) | def jobconfs(self):
    method init_local (line 698) | def init_local(self):
    method init_hadoop (line 708) | def init_hadoop(self):
    method run (line 714) | def run(self):
    method requires_local (line 726) | def requires_local(self):
    method requires_hadoop (line 732) | def requires_hadoop(self):
    method input_local (line 735) | def input_local(self):
    method input_hadoop (line 738) | def input_hadoop(self):
    method deps (line 741) | def deps(self):
    method on_failure (line 745) | def on_failure(self, exception):
  class JobTask (line 766) | class JobTask(BaseHadoopJobTask):
    method jobconfs (line 771) | def jobconfs(self):
    method init_mapper (line 781) | def init_mapper(self):
    method init_combiner (line 784) | def init_combiner(self):
    method init_reducer (line 787) | def init_reducer(self):
    method _setup_remote (line 790) | def _setup_remote(self):
    method job_runner (line 793) | def job_runner(self):
    method reader (line 810) | def reader(self, input_stream):
    method writer (line 818) | def writer(self, outputs, stdout, stderr=sys.stderr):
    method mapper (line 839) | def mapper(self, item):
    method incr_counter (line 849) | def incr_counter(self, *args, **kwargs):
    method _flush_batch_incr_counter (line 872) | def _flush_batch_incr_counter(self):
    method _incr_counter (line 883) | def _incr_counter(self, *args):
    method extra_modules (line 899) | def extra_modules(self):
    method extra_files (line 902) | def extra_files(self):
    method extra_streaming_arguments (line 915) | def extra_streaming_arguments(self):
    method extra_archives (line 922) | def extra_archives(self):
    method add_link (line 926) | def add_link(self, src, dst):
    method _setup_links (line 931) | def _setup_links(self):
    method dump (line 951) | def dump(self, directory=""):
    method _map_input (line 966) | def _map_input(self, input_stream):
    method _reduce_input (line 983) | def _reduce_input(self, inputs, reducer, final=NotImplemented):
    method run_mapper (line 995) | def run_mapper(self, stdin=sys.stdin, stdout=sys.stdout):
    method run_reducer (line 1007) | def run_reducer(self, stdin=sys.stdin, stdout=sys.stdout):
    method run_combiner (line 1016) | def run_combiner(self, stdin=sys.stdin, stdout=sys.stdout):
    method internal_reader (line 1022) | def internal_reader(self, input_stream):
    method internal_writer (line 1030) | def internal_writer(self, outputs, stdout):

FILE: luigi/contrib/hadoop_jar.py
  function fix_paths (line 33) | def fix_paths(job):
  class HadoopJarJobError (line 65) | class HadoopJarJobError(Exception):
  class HadoopJarJobRunner (line 69) | class HadoopJarJobRunner(luigi.contrib.hadoop.JobRunner):
    method __init__ (line 74) | def __init__(self):
    method run_job (line 77) | def run_job(self, job, tracking_url_callback=None):
  class HadoopJarJobTask (line 124) | class HadoopJarJobTask(luigi.contrib.hadoop.BaseHadoopJobTask):
    method jar (line 129) | def jar(self):
    method main (line 135) | def main(self):
    method job_runner (line 141) | def job_runner(self):
    method atomic_output (line 145) | def atomic_output(self):
    method ssh (line 152) | def ssh(self):
    method args (line 159) | def args(self):

FILE: luigi/contrib/hdfs/abstract_client.py
  class HdfsFileSystem (line 27) | class HdfsFileSystem(luigi.target.FileSystem, metaclass=abc.ABCMeta):
    method rename (line 32) | def rename(self, path, dest):
    method rename_dont_move (line 43) | def rename_dont_move(self, path, dest):
    method remove (line 57) | def remove(self, path, recursive=True, skip_trash=False):
    method chmod (line 61) | def chmod(self, path, permissions, recursive=False):
    method chown (line 65) | def chown(self, path, owner, group, recursive=False):
    method count (line 69) | def count(self, path):
    method copy (line 76) | def copy(self, path, destination):
    method put (line 80) | def put(self, local_path, destination):
    method get (line 84) | def get(self, path, local_destination):
    method mkdir (line 88) | def mkdir(self, path, parents=True, raise_if_exists=False):
    method listdir (line 92) | def listdir(self, path, ignore_directories=False, ignore_files=False, ...
    method touchz (line 96) | def touchz(self, path):

FILE: luigi/contrib/hdfs/clients.py
  function get_autoconfig_client (line 34) | def get_autoconfig_client(client_cache=_AUTOCONFIG_CLIENT):
  function _with_ac (line 51) | def _with_ac(method_name):

FILE: luigi/contrib/hdfs/config.py
  class hdfs (line 32) | class hdfs(luigi.Config):
  class hadoopcli (line 43) | class hadoopcli(luigi.Config):
  function load_hadoop_cmd (line 52) | def load_hadoop_cmd():
  function get_configured_hadoop_version (line 56) | def get_configured_hadoop_version():
  function get_configured_hdfs_client (line 68) | def get_configured_hdfs_client():
  function tmppath (line 77) | def tmppath(path=None, include_unix_username=True):

FILE: luigi/contrib/hdfs/error.py
  class HDFSCliError (line 23) | class HDFSCliError(Exception):
    method __init__ (line 24) | def __init__(self, command, returncode, stdout, stderr):

FILE: luigi/contrib/hdfs/format.py
  class HdfsAtomicWriteError (line 13) | class HdfsAtomicWriteError(IOError):
  class HdfsReadPipe (line 17) | class HdfsReadPipe(luigi.format.InputPipeProcessWrapper):
    method __init__ (line 18) | def __init__(self, path):
  class HdfsAtomicWritePipe (line 22) | class HdfsAtomicWritePipe(luigi.format.OutputPipeProcessWrapper):
    method __init__ (line 35) | def __init__(self, path):
    method abort (line 42) | def abort(self):
    method close (line 47) | def close(self):
  class HdfsAtomicWriteDirPipe (line 61) | class HdfsAtomicWriteDirPipe(luigi.format.OutputPipeProcessWrapper):
    method __init__ (line 66) | def __init__(self, path, data_extension=""):
    method abort (line 72) | def abort(self):
    method close (line 77) | def close(self):
  class PlainFormat (line 97) | class PlainFormat(luigi.format.Format):
    method hdfs_writer (line 101) | def hdfs_writer(self, path):
    method hdfs_reader (line 104) | def hdfs_reader(self, path):
    method pipe_reader (line 107) | def pipe_reader(self, path):
    method pipe_writer (line 110) | def pipe_writer(self, output_pipe):
  class PlainDirFormat (line 114) | class PlainDirFormat(luigi.format.Format):
    method hdfs_writer (line 118) | def hdfs_writer(self, path):
    method hdfs_reader (line 121) | def hdfs_reader(self, path):
    method pipe_reader (line 124) | def pipe_reader(self, path):
    method pipe_writer (line 128) | def pipe_writer(self, path):
  class CompatibleHdfsFormat (line 136) | class CompatibleHdfsFormat(luigi.format.Format):
    method __init__ (line 139) | def __init__(self, writer, reader, input=None):
    method pipe_writer (line 146) | def pipe_writer(self, output):
    method pipe_reader (line 149) | def pipe_reader(self, input):
    method hdfs_writer (line 152) | def hdfs_writer(self, output):
    method hdfs_reader (line 155) | def hdfs_reader(self, input):
    method __getstate__ (line 162) | def __getstate__(self):
    method __setstate__ (line 173) | def __setstate__(self, d):

FILE: luigi/contrib/hdfs/hadoopcli_clients.py
  function create_hadoopcli_client (line 38) | def create_hadoopcli_client():
  class HdfsClient (line 54) | class HdfsClient(hdfs_abstract_client.HdfsFileSystem):
    method call_check (line 62) | def call_check(command):
    method exists (line 69) | def exists(self, path):
    method move (line 88) | def move(self, path, dest):
    method remove (line 98) | def remove(self, path, recursive=True, skip_trash=False):
    method chmod (line 110) | def chmod(self, path, permissions, recursive=False):
    method chown (line 117) | def chown(self, path, owner, group, recursive=False):
    method count (line 129) | def count(self, path):
    method copy (line 141) | def copy(self, path, destination):
    method put (line 144) | def put(self, local_path, destination):
    method get (line 147) | def get(self, path, local_destination):
    method getmerge (line 150) | def getmerge(self, path, local_destination, new_line=False):
    method mkdir (line 157) | def mkdir(self, path, parents=True, raise_if_exists=False):
    method listdir (line 170) | def listdir(self, path, ignore_directories=False, ignore_files=False, ...
    method touchz (line 210) | def touchz(self, path):
  class HdfsClientCdh3 (line 214) | class HdfsClientCdh3(HdfsClient):
    method mkdir (line 219) | def mkdir(self, path, parents=True, raise_if_exists=False):
    method remove (line 232) | def remove(self, path, recursive=True, skip_trash=False):
  class HdfsClientApache1 (line 245) | class HdfsClientApache1(HdfsClientCdh3):
    method exists (line 253) | def exists(self, path):

FILE: luigi/contrib/hdfs/target.py
  class HdfsTarget (line 32) | class HdfsTarget(FileSystemTarget):
    method __init__ (line 33) | def __init__(self, path=None, format=None, is_tmp=False, fs=None):
    method __del__ (line 86) | def __del__(self):
    method fs (line 92) | def fs(self):
    method glob_exists (line 95) | def glob_exists(self, expected_files):
    method open (line 101) | def open(self, mode="r"):
    method remove (line 110) | def remove(self, skip_trash=False):
    method rename (line 113) | def rename(self, path, raise_if_exists=False):
    method move (line 126) | def move(self, path, raise_if_exists=False):
    method move_dir (line 132) | def move_dir(self, path):
    method copy (line 144) | def copy(self, dst_dir):
    method is_writable (line 150) | def is_writable(self):
    method _is_writable (line 172) | def _is_writable(self, path):
  class HdfsFlagTarget (line 182) | class HdfsFlagTarget(HdfsTarget):
    method __init__ (line 196) | def __init__(self, path, format=None, client=None, flag="_SUCCESS"):
    method exists (line 212) | def exists(self):

FILE: luigi/contrib/hdfs/webhdfs_client.py
  class webhdfs (line 38) | class webhdfs(luigi.Config):
  class WebHdfsClient (line 44) | class WebHdfsClient(hdfs_abstract_client.HdfsFileSystem):
    method __init__ (line 52) | def __init__(self, host=None, port=None, user=None, client_type=None):
    method url (line 59) | def url(self):
    method client (line 67) | def client(self):
    method walk (line 82) | def walk(self, path, depth=1):
    method exists (line 85) | def exists(self, path):
    method upload (line 100) | def upload(self, hdfs_path, local_path, overwrite=False):
    method download (line 103) | def download(self, hdfs_path, local_path, overwrite=False, n_threads=-1):
    method remove (line 106) | def remove(self, hdfs_path, recursive=True, skip_trash=False):
    method read (line 110) | def read(self, hdfs_path, offset=0, length=None, buffer_size=None, chu...
    method move (line 113) | def move(self, path, dest):
    method mkdir (line 121) | def mkdir(self, path, parents=True, mode=0o755, raise_if_exists=False):
    method chmod (line 130) | def chmod(self, path, permissions, recursive=False):
    method chown (line 136) | def chown(self, path, owner, group, recursive=False):
    method count (line 142) | def count(self, path):
    method copy (line 148) | def copy(self, path, destination):
    method put (line 154) | def put(self, local_path, destination):
    method get (line 160) | def get(self, path, local_destination):
    method listdir (line 166) | def listdir(self, path, ignore_directories=False, ignore_files=False, ...
    method touchz (line 170) | def touchz(self, path):

FILE: luigi/contrib/hive.py
  class HiveCommandError (line 37) | class HiveCommandError(RuntimeError):
    method __init__ (line 38) | def __init__(self, message, out=None, err=None):
  function load_hive_cmd (line 45) | def load_hive_cmd():
  function get_hive_syntax (line 49) | def get_hive_syntax():
  function get_hive_warehouse_location (line 53) | def get_hive_warehouse_location():
  function get_ignored_file_masks (line 57) | def get_ignored_file_masks():
  function run_hive (line 61) | def run_hive(args, check_return_code=True):
  function run_hive_cmd (line 78) | def run_hive_cmd(hivecmd, check_return_code=True):
  function run_hive_script (line 85) | def run_hive_script(script):
  function _is_ordered_dict (line 94) | def _is_ordered_dict(dikt):
  function _validate_partition (line 98) | def _validate_partition(partition):
  class HiveClient (line 107) | class HiveClient(metaclass=abc.ABCMeta):
    method table_location (line 109) | def table_location(self, table, database="default", partition=None):
    method table_schema (line 117) | def table_schema(self, table, database="default"):
    method table_exists (line 124) | def table_exists(self, table, database="default", partition=None):
    method partition_spec (line 132) | def partition_spec(self, partition):
  class HiveCommandClient (line 137) | class HiveCommandClient(HiveClient):
    method table_location (line 142) | def table_location(self, table, database="default", partition=None):
    method table_exists (line 153) | def table_exists(self, table, database="default", partition=None):
    method table_schema (line 170) | def table_schema(self, table, database="default"):
    method partition_spec (line 176) | def partition_spec(self, partition):
  class ApacheHiveCommandClient (line 183) | class ApacheHiveCommandClient(HiveCommandClient):
    method table_schema (line 189) | def table_schema(self, table, database="default"):
  class MetastoreClient (line 196) | class MetastoreClient(HiveClient):
    method table_location (line 197) | def table_location(self, table, database="default", partition=None):
    method table_exists (line 211) | def table_exists(self, table, database="default", partition=None):
    method _existing_partitions (line 218) | def _existing_partitions(self, table, database, client):
    method table_schema (line 230) | def table_schema(self, table, database="default"):
    method partition_spec (line 234) | def partition_spec(self, partition):
  class HiveThriftContext (line 238) | class HiveThriftContext:
    method __enter__ (line 243) | def __enter__(self):
    method __exit__ (line 264) | def __exit__(self, exc_type, exc_val, exc_tb):
  class WarehouseHiveClient (line 268) | class WarehouseHiveClient(HiveClient):
    method __init__ (line 273) | def __init__(self, hdfs_client=None, warehouse_location=None):
    method table_schema (line 277) | def table_schema(self, table, database="default"):
    method table_location (line 280) | def table_location(self, table, database="default", partition=None):
    method table_exists (line 283) | def table_exists(self, table, database="default", partition=None):
    method partition_spec (line 302) | def partition_spec(self, partition):
  function get_default_client (line 307) | def get_default_client():
  class HiveQueryTask (line 322) | class HiveQueryTask(luigi.contrib.hadoop.BaseHadoopJobTask):
    method query (line 333) | def query(self):
    method hiverc (line 337) | def hiverc(self):
    method hivevars (line 347) | def hivevars(self):
    method hiveconfs (line 356) | def hiveconfs(self):
    method job_runner (line 384) | def job_runner(self):
  class HiveQueryRunner (line 388) | class HiveQueryRunner(luigi.contrib.hadoop.JobRunner):
    method prepare_outputs (line 393) | def prepare_outputs(self, job):
    method get_arglist (line 412) | def get_arglist(self, f_name, job):
    method run_job (line 431) | def run_job(self, job, tracking_url_callback=None):
  class HivePartitionTarget (line 446) | class HivePartitionTarget(luigi.Target):
    method __init__ (line 451) | def __init__(self, table, partition, database="default", fail_missing_...
    method __str__ (line 468) | def __str__(self):
    method exists (line 471) | def exists(self):
    method path (line 491) | def path(self):
  class HiveTableTarget (line 501) | class HiveTableTarget(HivePartitionTarget):
    method __init__ (line 506) | def __init__(self, table, database="default", client=None):
  class ExternalHiveTask (line 516) | class ExternalHiveTask(luigi.ExternalTask):
    method output (line 527) | def output(self):

FILE: luigi/contrib/kubernetes.py
  class kubernetes (line 53) | class kubernetes(luigi.Config):
  class KubernetesJobTask (line 60) | class KubernetesJobTask(luigi.Task):
    method _init_kubernetes (line 65) | def _init_kubernetes(self):
    method auth_method (line 79) | def auth_method(self):
    method kubeconfig_path (line 92) | def kubeconfig_path(self):
    method kubernetes_namespace (line 108) | def kubernetes_namespace(self):
    method name (line 119) | def name(self):
    method labels (line 127) | def labels(self):
    method spec_schema (line 136) | def spec_schema(self):
    method max_retrials (line 163) | def max_retrials(self):
    method backoff_limit (line 170) | def backoff_limit(self):
    method delete_on_success (line 178) | def delete_on_success(self):
    method print_pod_logs_on_exit (line 185) | def print_pod_logs_on_exit(self):
    method active_deadline_seconds (line 192) | def active_deadline_seconds(self):
    method kubernetes_config (line 200) | def kubernetes_config(self):
    method poll_interval (line 206) | def poll_interval(self):
    method pod_creation_wait_interal (line 211) | def pod_creation_wait_interal(self):
    method __track_job (line 215) | def __track_job(self):
    method signal_complete (line 234) | def signal_complete(self):
    method __get_pods (line 245) | def __get_pods(self):
    method __get_job (line 249) | def __get_job(self):
    method __print_pod_logs (line 254) | def __print_pod_logs(self):
    method __print_kubectl_hints (line 262) | def __print_kubectl_hints(self):
    method __verify_job_has_started (line 267) | def __verify_job_has_started(self):
    method __get_job_status (line 299) | def __get_job_status(self):
    method __delete_job_cascade (line 322) | def __delete_job_cascade(self, job):
    method run (line 328) | def run(self):
    method output (line 356) | def output(self):

FILE: luigi/contrib/lsf.py
  function track_job (line 75) | def track_job(job_id):
  function kill_job (line 91) | def kill_job(job_id):
  class LSFJobTask (line 98) | class LSFJobTask(luigi.Task):
    method fetch_task_failures (line 117) | def fetch_task_failures(self):
    method fetch_task_output (line 129) | def fetch_task_output(self):
    method _init_local (line 141) | def _init_local(self):
    method init_local (line 171) | def init_local(self):
    method run (line 179) | def run(self):
    method work (line 192) | def work(self):
    method _dump (line 203) | def _dump(self, out_dir=""):
    method _run_job (line 217) | def _run_job(self):
    method _track_job (line 276) | def _track_job(self):
    method _finish (line 325) | def _finish(self):
    method __del__ (line 331) | def __del__(self):
  class LocalLSFJobTask (line 336) | class LocalLSFJobTask(LSFJobTask):
    method run (line 341) | def run(self):

FILE: luigi/contrib/lsf_runner.py
  function do_work_on_compute_node (line 36) | def do_work_on_compute_node(work_dir):
  function extract_packages_archive (line 49) | def extract_packages_archive(work_dir):
  function main (line 65) | def main(args=sys.argv):

FILE: luigi/contrib/mongodb.py
  class MongoTarget (line 21) | class MongoTarget(Target):
    method __init__ (line 24) | def __init__(self, mongo_client, index, collection):
    method __str__ (line 37) | def __str__(self):
    method get_collection (line 40) | def get_collection(self):
    method get_index (line 47) | def get_index(self):
  class MongoCellTarget (line 54) | class MongoCellTarget(MongoTarget):
    method __init__ (line 57) | def __init__(self, mongo_client, index, collection, document_id, path):
    method exists (line 69) | def exists(self):
    method read (line 76) | def read(self):
    method write (line 89) | def write(self, value):
  class MongoRangeTarget (line 96) | class MongoRangeTarget(MongoTarget):
    method __init__ (line 99) | def __init__(self, mongo_client, index, collection, document_ids, field):
    method exists (line 111) | def exists(self):
    method read (line 118) | def read(self):
    method write (line 126) | def write(self, values):
    method get_empty_ids (line 143) | def get_empty_ids(self):
  class MongoCollectionTarget (line 152) | class MongoCollectionTarget(MongoTarget):
    method __init__ (line 155) | def __init__(self, mongo_client, index, collection):
    method exists (line 158) | def exists(self):
    method read (line 165) | def read(self):
  class MongoCountTarget (line 172) | class MongoCountTarget(MongoTarget):
    method __init__ (line 175) | def __init__(self, mongo_client, index, collection, target_count):
    method exists (line 184) | def exists(self):
    method read (line 191) | def read(self):

FILE: luigi/contrib/mssqldb.py
  class MSSqlTarget (line 33) | class MSSqlTarget(luigi.Target):
    method __init__ (line 44) | def __init__(self, host, database, user, password, table, update_id):
    method __str__ (line 71) | def __str__(self):
    method touch (line 74) | def touch(self, connection=None):
    method exists (line 106) | def exists(self, connection=None):
    method connect (line 125) | def connect(self):
    method create_marker_table (line 132) | def create_marker_table(self):

FILE: luigi/contrib/mysqldb.py
  class MySqlTarget (line 35) | class MySqlTarget(luigi.Target):
    method __init__ (line 42) | def __init__(self, host, database, user, password, table, update_id, *...
    method __str__ (line 72) | def __str__(self):
    method touch (line 75) | def touch(self, connection=None):
    method exists (line 100) | def exists(self, connection=None):
    method connect (line 120) | def connect(self, autocommit=False):
    method create_marker_table (line 126) | def create_marker_table(self):
  class CopyToTable (line 154) | class CopyToTable(rdbms.CopyToTable):
    method rows (line 166) | def rows(self):
    method output (line 176) | def output(self):
    method copy (line 184) | def copy(self, cursor, file=None):
    method run (line 199) | def run(self):
    method bulk_size (line 241) | def bulk_size(self):

FILE: luigi/contrib/opener.py
  class OpenerError (line 45) | class OpenerError(FileSystemException):
  class NoOpenerError (line 51) | class NoOpenerError(OpenerError):
  class InvalidQuery (line 57) | class InvalidQuery(OpenerError):
  class OpenerRegistry (line 63) | class OpenerRegistry:
    method __init__ (line 64) | def __init__(self, openers=None):
    method get_opener (line 81) | def get_opener(self, name):
    method add (line 94) | def add(self, opener):
    method open (line 107) | def open(self, target_uri, **kwargs):
  class Opener (line 127) | class Opener:
    method conform_query (line 136) | def conform_query(cls, query):
    method get_target (line 165) | def get_target(cls, scheme, path, fragment, username, password, hostna...
  class MockOpener (line 173) | class MockOpener(Opener):
    method get_target (line 190) | def get_target(cls, scheme, path, fragment, username, password, hostna...
  class LocalOpener (line 196) | class LocalOpener(Opener):
    method get_target (line 214) | def get_target(cls, scheme, path, fragment, username, password, hostna...
  class S3Opener (line 220) | class S3Opener(Opener):
    method get_target (line 237) | def get_target(cls, scheme, path, fragment, username, password, hostna...

FILE: luigi/contrib/pai.py
  function slot_to_dict (line 51) | def slot_to_dict(o):
  class PaiJob (line 61) | class PaiJob:
    method __init__ (line 103) | def __init__(self, jobName, image, tasks):
  class Port (line 119) | class Port:
    method __init__ (line 122) | def __init__(self, label, begin_at=0, port_number=1):
  class TaskRole (line 135) | class TaskRole:
    method __init__ (line 138) | def __init__(self, name, command, taskNumber=1, cpuNumber=1, memoryMB=...
  class OpenPai (line 161) | class OpenPai(luigi.Config):
  class PaiTask (line 168) | class PaiTask(luigi.Task):
    method name (line 173) | def name(self):
    method image (line 179) | def image(self):
    method tasks (line 185) | def tasks(self):
    method auth_file_path (line 190) | def auth_file_path(self):
    method data_dir (line 195) | def data_dir(self):
    method code_dir (line 200) | def code_dir(self):
    method output_dir (line 205) | def output_dir(self):
    method virtual_cluster (line 210) | def virtual_cluster(self):
    method gpu_type (line 215) | def gpu_type(self):
    method retry_count (line 220) | def retry_count(self):
    method __init_token (line 224) | def __init_token(self):
    method __init__ (line 238) | def __init__(self, *args, **kwargs):
    method __check_job_status (line 246) | def __check_job_status(self):
    method run (line 269) | def run(self):
    method output (line 294) | def output(self):
    method complete (line 297) | def complete(self):

FILE: luigi/contrib/pig.py
  class PigJobTask (line 41) | class PigJobTask(luigi.Task):
    method pig_home (line 42) | def pig_home(self):
    method pig_command_path (line 45) | def pig_command_path(self):
    method pig_env_vars (line 48) | def pig_env_vars(self):
    method pig_properties (line 57) | def pig_properties(self):
    method pig_parameters (line 67) | def pig_parameters(self):
    method pig_options (line 77) | def pig_options(self):
    method output (line 87) | def output(self):
    method pig_script_path (line 90) | def pig_script_path(self):
    method _build_pig_cmd (line 97) | def _build_pig_cmd(self):
    method run (line 123) | def run(self):
    method track_and_progress (line 127) | def track_and_progress(self, cmd):
  class PigRunContext (line 168) | class PigRunContext:
    method __init__ (line 169) | def __init__(self):
    method __enter__ (line 172) | def __enter__(self):
    method kill_job (line 177) | def kill_job(self, captured_signal=None, stack_frame=None):
    method __exit__ (line 185) | def __exit__(self, exc_type, exc_val, exc_tb):
  class PigJobError (line 191) | class PigJobError(RuntimeError):
    method __init__ (line 192) | def __init__(self, message, out=None, err=None):
    method __str__ (line 198) | def __str__(self):

FILE: luigi/contrib/postgres.py
  function update_error_codes (line 45) | def update_error_codes():
  function _is_pg8000_error (line 75) | def _is_pg8000_error(exception):
  function _pg8000_connection_reset (line 87) | def _pg8000_connection_reset(connection):
  function db_error_code (line 97) | def db_error_code(exception):
  class MultiReplacer (line 111) | class MultiReplacer:
    method __init__ (line 138) | def __init__(self, replace_pairs):
    method _replacer (line 150) | def _replacer(self, match_object):
    method __call__ (line 154) | def __call__(self, search_string):
  class PostgresTarget (line 164) | class PostgresTarget(luigi.Target):
    method __init__ (line 179) | def __init__(self, host, database, user, password, table, update_id, p...
    method __str__ (line 201) | def __str__(self):
    method touch (line 204) | def touch(self, connection=None):
    method exists (line 234) | def exists(self, connection=None):
    method connect (line 254) | def connect(self):
    method create_marker_table (line 262) | def create_marker_table(self):
    method open (line 293) | def open(self, mode):
  class CopyToTable (line 297) | class CopyToTable(rdbms.CopyToTable):
    method rows (line 309) | def rows(self):
    method map_column (line 317) | def map_column(self, value):
    method output (line 330) | def output(self):
    method copy (line 340) | def copy(self, cursor, file):
    method run (line 357) | def run(self):
  class PostgresQuery (line 420) | class PostgresQuery(rdbms.Query):
    method run (line 435) | def run(self):
    method output (line 451) | def output(self):

FILE: luigi/contrib/presto.py
  class presto (line 22) | class presto(luigi.Config):  # NOQA
  class PrestoClient (line 32) | class PrestoClient:
    method __init__ (line 38) | def __init__(self, connection, sleep_time=1):
    method percentage_progress (line 44) | def percentage_progress(self):
    method info_uri (line 51) | def info_uri(self):
    method execute (line 57) | def execute(self, query, parameters=None, mode=None):
  class WithPrestoClient (line 88) | class WithPrestoClient(Register):
    method __new__ (line 95) | def __new__(cls, name, bases, attrs):
  class PrestoTarget (line 118) | class PrestoTarget(luigi.Target):
    method __init__ (line 123) | def __init__(self, client, catalog, database, table, partition=None):
    method __str__ (line 131) | def __str__(self):
    method _count_query (line 135) | def _count_query(self):
    method _table_doesnot_exist (line 148) | def _table_doesnot_exist(self, exception):
    method count (line 157) | def count(self):
    method exists (line 167) | def exists(self):
  class PrestoTask (line 182) | class PrestoTask(rdbms.Query, metaclass=WithPrestoClient):
    method host (line 191) | def host(self):
    method port (line 195) | def port(self):
    method user (line 199) | def user(self):
    method username (line 203) | def username(self):
    method schema (line 207) | def schema(self):
    method password (line 211) | def password(self):
    method catalog (line 215) | def catalog(self):
    method poll_interval (line 219) | def poll_interval(self):
    method source (line 223) | def source(self):
    method partition (line 227) | def partition(self):
    method protocol (line 231) | def protocol(self):
    method session_props (line 235) | def session_props(self):
    method requests_session (line 239) | def requests_session(self):
    method requests_kwargs (line 243) | def requests_kwargs(self):
    method _maybe_set_tracking_url (line 248) | def _maybe_set_tracking_url(self):
    method _set_progress (line 253) | def _set_progress(self):
    method run (line 256) | def run(self):
    method output (line 261) | def output(self):

FILE: luigi/contrib/prometheus_metric.py
  class prometheus (line 8) | class prometheus(Config):
  class PrometheusMetricsCollector (line 13) | class PrometheusMetricsCollector(MetricsCollector):
    method _generate_task_labels (line 14) | def _generate_task_labels(self, task):
    method __init__ (line 17) | def __init__(self, *args, **kwargs):
    method generate_latest (line 32) | def generate_latest(self):
    method handle_task_started (line 35) | def handle_task_started(self, task):
    method handle_task_failed (line 39) | def handle_task_failed(self, task):
    method handle_task_disabled (line 43) | def handle_task_disabled(self, task, config):
    method handle_task_done (line 47) | def handle_task_done(self, task):
    method configure_http_handler (line 53) | def configure_http_handler(self, http_handler):

FILE: luigi/contrib/pyspark_runner.py
  class _SparkEntryPoint (line 41) | class _SparkEntryPoint(metaclass=abc.ABCMeta):
    method __init__ (line 42) | def __init__(self, conf):
    method __enter__ (line 46) | def __enter__(self):
    method __exit__ (line 50) | def __exit__(self, exc_type, exc_val, exc_tb):
  class SparkContextEntryPoint (line 54) | class SparkContextEntryPoint(_SparkEntryPoint):
    method __enter__ (line 57) | def __enter__(self):
    method __exit__ (line 63) | def __exit__(self, exc_type, exc_val, exc_tb):
  class SparkSessionEntryPoint (line 67) | class SparkSessionEntryPoint(_SparkEntryPoint):
    method _check_major_spark_version (line 70) | def _check_major_spark_version(self):
    method __enter__ (line 82) | def __enter__(self):
    method __exit__ (line 90) | def __exit__(self, exc_type, exc_val, exc_tb):
  class AbstractPySparkRunner (line 94) | class AbstractPySparkRunner(object):
    method __init__ (line 97) | def __init__(self, job, *args):
    method run (line 105) | def run(self):
  function _pyspark_runner_with (line 115) | def _pyspark_runner_with(name, entry_point_class):
  function _use_spark_session (line 123) | def _use_spark_session():
  function _get_runner_class (line 127) | def _get_runner_class():

FILE: luigi/contrib/rdbms.py
  class _MetadataColumnsMixin (line 33) | class _MetadataColumnsMixin:
    method metadata_columns (line 91) | def metadata_columns(self):
    method metadata_queries (line 99) | def metadata_queries(self):
    method enable_metadata_columns (line 103) | def enable_metadata_columns(self):
    method _add_metadata_columns (line 106) | def _add_metadata_columns(self, connection):
    method _column_exists (line 120) | def _column_exists(self, cursor, column_name):
    method _add_column_to_table (line 137) | def _add_column_to_table(self, cursor, column):
    method post_copy_metacolumns (line 149) | def post_copy_metacolumns(self, cursor):
  class CopyToTable (line 155) | class CopyToTable(luigi.task.MixinNaiveBulkComplete, _MetadataColumnsMix...
    method host (line 174) | def host(self):
    method database (line 179) | def database(self):
    method user (line 184) | def user(self):
    method password (line 189) | def password(self):
    method table (line 194) | def table(self):
    method port (line 198) | def port(self):
    method create_table (line 213) | def create_table(self, connection):
    method update_id (line 232) | def update_id(self):
    method output (line 239) | def output(self):
    method init_copy (line 242) | def init_copy(self, connection):
    method post_copy (line 259) | def post_copy(self, connection):
    method copy (line 269) | def copy(self, cursor, file):
  class Query (line 273) | class Query(luigi.task.MixinNaiveBulkComplete, luigi.Task):
    method host (line 302) | def host(self):
    method port (line 310) | def port(self):
    method database (line 318) | def database(self):
    method user (line 323) | def user(self):
    method password (line 328) | def password(self):
    method table (line 333) | def table(self):
    method query (line 338) | def query(self):
    method autocommit (line 342) | def autocommit(self):
    method update_id (line 346) | def update_id(self):
    method run (line 353) | def run(self):
    method output (line 357) | def output(self):

FILE: luigi/contrib/redis_store.py
  class RedisTarget (line 33) | class RedisTarget(Target):
    method __init__ (line 38) | def __init__(self, host, port, db, update_id, password=None, socket_ti...
    method __str__ (line 72) | def __str__(self):
    method marker_key (line 75) | def marker_key(self):
    method touch (line 81) | def touch(self):
    method exists (line 94) | def exists(self):

FILE: luigi/contrib/redshift.py
  class _CredentialsMixin (line 38) | class _CredentialsMixin:
    method configuration_section (line 46) | def configuration_section(self):
    method aws_access_key_id (line 54) | def aws_access_key_id(self):
    method aws_secret_access_key (line 61) | def aws_secret_access_key(self):
    method aws_account_id (line 68) | def aws_account_id(self):
    method aws_arn_role_name (line 75) | def aws_arn_role_name(self):
    method aws_session_token (line 82) | def aws_session_token(self):
    method _get_configuration_attribute (line 88) | def _get_configuration_attribute(self, attribute):
    method _credentials (line 98) | def _credentials(self):
  class RedshiftTarget (line 121) | class RedshiftTarget(postgres.PostgresTarget):
  class S3CopyToTable (line 137) | class S3CopyToTable(rdbms.CopyToTable, _CredentialsMixin):
    method s3_load_path (line 159) | def s3_load_path(self):
    method copy_options (line 167) | def copy_options(self):
    method prune_table (line 180) | def prune_table(self):
    method prune_column (line 189) | def prune_column(self):
    method prune_date (line 198) | def prune_date(self):
    method table_attributes (line 207) | def table_attributes(self):
    method table_constraints (line 218) | def table_constraints(self):
    method do_truncate_table (line 228) | def do_truncate_table(self):
    method do_prune (line 234) | def do_prune(self):
    method table_type (line 248) | def table_type(self):
    method queries (line 255) | def queries(self):
    method truncate_table (line 261) | def truncate_table(self, connection):
    method prune (line 269) | def prune(self, connection):
    method create_schema (line 277) | def create_schema(self, connection):
    method create_table (line 287) | def create_table(self, connection):
    method run (line 331) | def run(self):
    method copy (line 358) | def copy(self, cursor, f):
    method output (line 378) | def output(self):
    method does_schema_exist (line 386) | def does_schema_exist(self, connection):
    method does_table_exist (line 405) | def does_table_exist(self, connection):
    method init_copy (line 422) | def init_copy(self, connection):
    method post_copy (line 445) | def post_copy(self, cursor):
    method post_copy_metacolums (line 453) | def post_copy_metacolums(self, cursor):
  class S3CopyJSONToTable (line 462) | class S3CopyJSONToTable(S3CopyToTable, _CredentialsMixin):
    method jsonpath (line 487) | def jsonpath(self):
    method copy_json_options (line 495) | def copy_json_options(self):
    method copy (line 504) | def copy(self, cursor, f):
  class RedshiftManifestTask (line 521) | class RedshiftManifestTask(S3PathTask):
    method run (line 548) | def run(self):
  class KillOpenRedshiftSessions (line 564) | class KillOpenRedshiftSessions(luigi.Task):
    method host (line 584) | def host(self):
    method database (line 589) | def database(self):
    method user (line 594) | def user(self):
    method password (line 599) | def password(self):
    method update_id (line 603) | def update_id(self):
    method output (line 610) | def output(self):
    method run (line 621) | def run(self):
  class RedshiftQuery (line 657) | class RedshiftQuery(postgres.PostgresQuery):
    method output (line 671) | def output(self):
  class RedshiftUnloadTask (line 680) | class RedshiftUnloadTask(postgres.PostgresQuery, _CredentialsMixin):
    method s3_unload_path (line 694) | def s3_unload_path(self):
    method unload_options (line 701) | def unload_options(self):
    method unload_query (line 708) | def unload_query(self):
    method run (line 714) | def run(self):
    method output (line 734) | def output(self):

FILE: luigi/contrib/s3.py
  class InvalidDeleteException (line 53) | class InvalidDeleteException(FileSystemException):
  class FileNotFoundException (line 57) | class FileNotFoundException(FileSystemException):
  class DeprecatedBotoClientException (line 61) | class DeprecatedBotoClientException(Exception):
  class S3Client (line 65) | class S3Client(FileSystem):
    method __init__ (line 74) | def __init__(self, aws_access_key_id=None, aws_secret_access_key=None,...
    method s3 (line 87) | def s3(self):
    method s3 (line 139) | def s3(self, value):
    method exists (line 142) | def exists(self, path):
    method remove (line 162) | def remove(self, path, recursive=True):
    method move (line 202) | def move(self, source_path, destination_path, **kwargs):
    method get_key (line 212) | def get_key(self, path):
    method put (line 221) | def put(self, local_path, destination_s3_path, **kwargs):
    method put_string (line 233) | def put_string(self, content, destination_s3_path, **kwargs):
    method put_multipart (line 246) | def put_multipart(self, local_path, destination_s3_path, part_size=DEF...
    method copy (line 267) | def copy(self, source_path, destination_path, threads=DEFAULT_THREADS,...
    method _copy_file (line 291) | def _copy_file(self, source_path, destination_path, threads=DEFAULT_TH...
    method _copy_dir (line 302) | def _copy_dir(self, source_path, destination_path, threads=DEFAULT_THR...
    method get (line 335) | def get(self, s3_path, destination_local_path):
    method get_as_bytes (line 343) | def get_as_bytes(self, s3_path):
    method get_as_string (line 355) | def get_as_string(self, s3_path, encoding="utf-8"):
    method isdir (line 366) | def isdir(self, path):
    method mkdir (line 397) | def mkdir(self, path, parents=True, raise_if_exists=False):
    method listdir (line 413) | def listdir(self, path, start_time=None, end_time=None, return_key=Fal...
    method list (line 448) | def list(self, path, start_time=None, end_time=None, return_key=False)...
    method _get_s3_config (line 466) | def _get_s3_config(key=None):
    method _path_to_bucket_and_key (line 485) | def _path_to_bucket_and_key(path):
    method _is_root (line 492) | def _is_root(key):
    method _add_path_delimiter (line 496) | def _add_path_delimiter(key):
    method _check_deprecated_argument (line 500) | def _check_deprecated_argument(**kwargs):
    method _exists (line 515) | def _exists(self, bucket, key):
  class AtomicS3File (line 527) | class AtomicS3File(AtomicLocalFile):
    method __init__ (line 534) | def __init__(self, path, s3_client, **kwargs):
    method move_to_final_destination (line 539) | def move_to_final_destination(self):
  class ReadableS3File (line 543) | class ReadableS3File:
    method __init__ (line 544) | def __init__(self, s3_key):
    method read (line 550) | def read(self, size=None):
    method close (line 554) | def close(self):
    method __del__ (line 558) | def __del__(self):
    method __exit__ (line 561) | def __exit__(self, exc_type, exc, traceback):
    method __enter__ (line 564) | def __enter__(self):
    method _add_to_buffer (line 567) | def _add_to_buffer(self, line):
    method _flush_buffer (line 570) | def _flush_buffer(self):
    method readable (line 575) | def readable(self):
    method writable (line 578) | def writable(self):
    method seekable (line 581) | def seekable(self):
    method __iter__ (line 584) | def __iter__(self):
  class S3Target (line 614) | class S3Target(FileSystemTarget):
    method __init__ (line 623) | def __init__(self, path, format=None, client=None, **kwargs):
    method open (line 633) | def open(self, mode="r"):
  class S3FlagTarget (line 648) | class S3FlagTarget(S3Target):
    method __init__ (line 670) | def __init__(self, path, format=None, client=None, flag="_SUCCESS"):
    method exists (line 689) | def exists(self):
  class S3EmrTarget (line 694) | class S3EmrTarget(S3FlagTarget):
    method __init__ (line 699) | def __init__(self, *args, **kwargs):
  class S3PathTask (line 704) | class S3PathTask(ExternalTask):
    method output (line 711) | def output(self):
  class S3EmrTask (line 715) | class S3EmrTask(ExternalTask):
    method output (line 722) | def output(self):
  class S3FlagTask (line 726) | class S3FlagTask(ExternalTask):
    method output (line 734) | def output(self):

FILE: luigi/contrib/salesforce.py
  function get_soql_fields (line 39) | def get_soql_fields(soql):
  function ensure_utf (line 51) | def ensure_utf(value):
  function parse_results (line 55) | def parse_results(fields, data):
  function _traverse_results (line 76) | def _traverse_results(value, fields, row, path):
  class salesforce (line 93) | class salesforce(luigi.Config):
  class QuerySalesforce (line 108) | class QuerySalesforce(Task):
    method object_name (line 111) | def object_name(self):
    method use_sandbox (line 119) | def use_sandbox(self):
    method sandbox_name (line 127) | def sandbox_name(self):
    method soql (line 133) | def soql(self):
    method is_soql_file (line 138) | def is_soql_file(self):
    method content_type (line 143) | def content_type(self):
    method run (line 149) | def run(self):
    method merge_batch_results (line 207) | def merge_batch_results(self, result_ids):
  class SalesforceAPI (line 227) | class SalesforceAPI:
    method __init__ (line 237) | def __init__(self, username, password, security_token, sb_token=None, ...
    method start_session (line 251) | def start_session(self):
    method has_active_session (line 276) | def has_active_session(self):
    method query (line 279) | def query(self, query, **kwargs):
    method query_more (line 292) | def query_more(self, next_records_identifier, identifier_is_url=False,...
    method query_all (line 318) | def query_all(self, query, **kwargs):
    method restful (line 364) | def restful(self, path, params):
    method create_operation_job (line 383) | def create_operation_job(self, operation, obj, external_id_field_name=...
    method get_job_details (line 405) | def get_job_details(self, job_id):
    method abort_job (line 418) | def abort_job(self, job_id):
    method close_job (line 431) | def close_job(self, job_id):
    method create_batch (line 446) | def create_batch(self, job_id, data, file_type):
    method block_on_batch (line 472) | def block_on_batch(self, job_id, batch_id, sleep_time_seconds=5, max_w...
    method get_batch_results (line 497) | def get_batch_results(self, job_id, batch_id):
    method get_batch_result_ids (line 504) | def get_batch_result_ids(self, job_id, batch_id):
    method get_batch_result (line 520) | def get_batch_result(self, job_id, batch_id, result_id):
    method _get_batch_info (line 533) | def _get_batch_info(self, job_id, batch_id):
    method _get_login_url (line 548) | def _get_login_url(self):
    method _get_base_url (line 552) | def _get_base_url(self):
    method _get_bulk_base_url (line 555) | def _get_bulk_base_url(self):
    method _get_norm_base_url (line 559) | def _get_norm_base_url(self):
    method _get_norm_query_url (line 563) | def _get_norm_query_url(self):
    method _get_create_job_url (line 567) | def _get_create_job_url(self):
    method _get_job_id_url (line 571) | def _get_job_id_url(self, job_id):
    method _get_job_details_url (line 575) | def _get_job_details_url(self, job_id):
    method _get_abort_job_url (line 579) | def _get_abort_job_url(self, job_id):
    method _get_close_job_url (line 583) | def _get_close_job_url(self, job_id):
    method _get_create_batch_url (line 587) | def _get_create_batch_url(self, job_id):
    method _get_batch_info_url (line 591) | def _get_batch_info_url(self, job_id, batch_id):
    method _get_batch_results_url (line 595) | def _get_batch_results_url(self, job_id, batch_id):
    method _get_batch_result_url (line 599) | def _get_batch_result_url(self, job_id, batch_id, result_id):
    method _get_login_headers (line 603) | def _get_login_headers(self):
    method _get_session_headers (line 607) | def _get_session_headers(self):
    method _get_norm_session_headers (line 611) | def _get_norm_session_headers(self):
    method _get_rest_headers (line 615) | def _get_rest_headers(self):
    method _get_job_headers (line 620) | def _get_job_headers(self):
    method _get_create_job_headers (line 625) | def _get_create_job_headers(self):
    method _get_abort_job_headers (line 628) | def _get_abort_job_headers(self):
    method _get_close_job_headers (line 631) | def _get_close_job_headers(self):
    method _get_create_batch_content_headers (line 634) | def _get_create_batch_content_headers(self, content_type):
    method _get_batch_info_headers (line 640) | def _get_batch_info_headers(self):
    method _get_login_xml (line 643) | def _get_login_xml(self):
    method _get_create_job_xml (line 657) | def _get_create_job_xml(self, operation, obj, external_id_field_name, ...
    method _get_abort_job_xml (line 671) | def _get_abort_job_xml(self):
    method _get_close_job_xml (line 678) | def _get_close_job_xml(self):

FILE: luigi/contrib/scalding.py
  class ScaldingJobRunner (line 61) | class ScaldingJobRunner(luigi.contrib.hadoop.JobRunner):
    method __init__ (line 66) | def __init__(self):
    method _get_jars (line 79) | def _get_jars(self, path):
    method get_scala_jars (line 82) | def get_scala_jars(self, include_compiler=False):
    method get_scalding_jars (line 96) | def get_scalding_jars(self):
    method get_scalding_core (line 100) | def get_scalding_core(self):
    method get_provided_jars (line 109) | def get_provided_jars(self):
    method get_libjars (line 112) | def get_libjars(self):
    method get_tmp_job_jar (line 115) | def get_tmp_job_jar(self, source):
    method get_build_dir (line 119) | def get_build_dir(self, source):
    method get_job_class (line 123) | def get_job_class(self, source):
    method build_job_jar (line 146) | def build_job_jar(self, job):
    method run_job (line 186) | def run_job(self, job, tracking_url_callback=None):
  class ScaldingJobTask (line 217) | class ScaldingJobTask(luigi.contrib.hadoop.BaseHadoopJobTask):
    method relpath (line 232) | def relpath(self, current_file, rel_path):
    method source (line 240) | def source(self):
    method jar (line 248) | def jar(self):
    method extra_jars (line 256) | def extra_jars(self):
    method job_class (line 262) | def job_class(self):
    method job_runner (line 268) | def job_runner(self):
    method atomic_output (line 271) | def atomic_output(self):
    method requires (line 278) | def requires(self):
    method job_args (line 281) | def job_args(self):
    method args (line 287) | def args(self):

FILE: luigi/contrib/sge.py
  function _parse_qstat_state (line 110) | def _parse_qstat_state(qstat_out, job_id):
  function _parse_qsub_job_id (line 131) | def _parse_qsub_job_id(qsub_out):
  function _build_qsub_command (line 142) | def _build_qsub_command(cmd, job_name, outfile, errfile, pe, n_cpu):
  class SGEJobTask (line 148) | class SGEJobTask(luigi.Task):
    method __init__ (line 190) | def __init__(self, *args, **kwargs):
    method _fetch_task_failures (line 202) | def _fetch_task_failures(self):
    method _init_local (line 214) | def _init_local(self):
    method run (line 238) | def run(self):
    method work (line 252) | def work(self):
    method _dump (line 256) | def _dump(self, out_dir=""):
    method _run_job (line 270) | def _run_job(self):
    method _track_job (line 298) | def _track_job(self):
  class LocalSGEJobTask (line 328) | class LocalSGEJobTask(SGEJobTask):
    method run (line 336) | def run(self):

FILE: luigi/contrib/sge_runner.py
  function _do_work_on_compute_node (line 43) | def _do_work_on_compute_node(work_dir, tarball=True):
  function _extract_packages_archive (line 60) | def _extract_packages_archive(work_dir):
  function main (line 76) | def main(args=sys.argv):

FILE: luigi/contrib/simulate.py
  class RunAnywayTarget (line 32) | class RunAnywayTarget(luigi.Target):
    method __init__ (line 63) | def __init__(self, task_obj):
    method __str__ (line 83) | def __str__(self):
    method get_path (line 86) | def get_path(self):
    method exists (line 95) | def exists(self):
    method done (line 101) | def done(self):

FILE: luigi/contrib/spark.py
  class SparkSubmitTask (line 36) | class SparkSubmitTask(ExternalProgramTask):
    method tracking_url_pattern (line 59) | def tracking_url_pattern(self):
    method app_options (line 66) | def app_options(self):
    method pyspark_python (line 74) | def pyspark_python(self):
    method pyspark_driver_python (line 78) | def pyspark_driver_python(self):
    method hadoop_user_name (line 82) | def hadoop_user_name(self):
    method spark_version (line 86) | def spark_version(self):
    method spark_submit (line 90) | def spark_submit(self):
    method master (line 94) | def master(self):
    method deploy_mode (line 98) | def deploy_mode(self):
    method jars (line 102) | def jars(self):
    method packages (line 106) | def packages(self):
    method py_files (line 110) | def py_files(self):
    method files (line 114) | def files(self):
    method _conf (line 118) | def _conf(self):
    method conf (line 127) | def conf(self):
    method properties_file (line 131) | def properties_file(self):
    method driver_memory (line 135) | def driver_memory(self):
    method driver_java_options (line 139) | def driver_java_options(self):
    method driver_library_path (line 143) | def driver_library_path(self):
    method driver_class_path (line 147) | def driver_class_path(self):
    method executor_memory (line 151) | def executor_memory(self):
    method driver_cores (line 155) | def driver_cores(self):
    method supervise (line 159) | def supervise(self):
    method total_executor_cores (line 163) | def total_executor_cores(self):
    method executor_cores (line 167) | def executor_cores(self):
    method queue (line 171) | def queue(self):
    method num_executors (line 175) | def num_executors(self):
    method archives (line 179) | def archives(self):
    method hadoop_conf_dir (line 183) | def hadoop_conf_dir(self):
    method get_environment (line 186) | def get_environment(self):
    method program_environment (line 194) | def program_environment(self):
    method program_args (line 197) | def program_args(self):
    method spark_command (line 200) | def spark_command(self):
    method app_command (line 226) | def app_command(self):
    method _list_config (line 231) | def _list_config(self, config):
    method _dict_config (line 235) | def _dict_config(self, config):
    method _text_arg (line 239) | def _text_arg(self, name, value):
    method _list_arg (line 244) | def _list_arg(self, name, value):
    method _dict_arg (line 249) | def _dict_arg(self, name, value):
    method _flag_arg (line 256) | def _flag_arg(self, name, value):
  class PySparkTask (line 262) | class PySparkTask(SparkSubmitTask):
    method name (line 277) | def name(self):
    method py_packages (line 281) | def py_packages(self):
    method files (line 287) | def files(self):
    method pickle_protocol (line 292) | def pickle_protocol(self):
    method setup (line 295) | def setup(self, conf):
    method setup_remote (line 302) | def setup_remote(self, sc):
    method main (line 305) | def main(self, sc, *args):
    method app_command (line 314) | def app_command(self):
    method run (line 321) | def run(self):
    method _dump (line 335) | def _dump(self, fd):
    method _setup_packages (line 345) | def _setup_packages(self, sc):

FILE: luigi/contrib/sparkey.py
  class SparkeyExportTask (line 21) | class SparkeyExportTask(luigi.Task):
    method __init__ (line 38) | def __init__(self, *args, **kwargs):
    method run (line 41) | def run(self):
    method _write_sparkey_file (line 44) | def _write_sparkey_file(self):

FILE: luigi/contrib/sqla.py
  class SQLAlchemyTarget (line 154) | class SQLAlchemyTarget(luigi.Target):
    method __init__ (line 168) | def __init__(self, connection_string, target_table, update_id, echo=Fa...
    method __str__ (line 194) | def __str__(self):
    method engine (line 198) | def engine(self):
    method touch (line 213) | def touch(self):
    method exists (line 234) | def exists(self):
    method create_marker_table (line 244) | def create_marker_table(self):
    method open (line 270) | def open(self, mode):
  class CopyToTable (line 274) | class CopyToTable(luigi.Task):
    method connection_string (line 292) | def connection_string(self):
    method table (line 297) | def table(self):
    method create_table (line 323) | def create_table(self, engine):
    method update_id (line 364) | def update_id(self):
    method output (line 370) | def output(self):
    method rows (line 375) | def rows(self):
    method run (line 385) | def run(self):
    method copy (line 400) | def copy(self, conn, ins_rows, table_bound):

FILE: luigi/contrib/ssh.py
  class RemoteCalledProcessError (line 54) | class RemoteCalledProcessError(subprocess.CalledProcessError):
    method __init__ (line 55) | def __init__(self, returncode, command, host, output=None):
    method __str__ (line 59) | def __str__(self):
  class RemoteContext (line 63) | class RemoteContext:
    method __init__ (line 64) | def __init__(self, host, **kwargs):
    method __repr__ (line 74) | def __repr__(self):
    method __eq__ (line 77) | def __eq__(self, other):
    method __hash__ (line 80) | def __hash__(self):
    method _host_ref (line 83) | def _host_ref(self):
    method _prepare_cmd (line 89) | def _prepare_cmd(self, cmd):
    method Popen (line 111) | def Popen(self, cmd, **kwargs):
    method check_output (line 118) | def check_output(self, cmd):
    method tunnel (line 131) | def tunnel(self, local_port, remote_port=None, remote_host="localhost"):
  class RemoteFileSystem (line 153) | class RemoteFileSystem(luigi.target.FileSystem):
    method __init__ (line 154) | def __init__(self, host, **kwargs):
    method exists (line 157) | def exists(self, path):
    method listdir (line 170) | def listdir(self, path):
    method isdir (line 178) | def isdir(self, path):
    method remove (line 191) | def remove(self, path, recursive=True):
    method mkdir (line 202) | def mkdir(self, path, parents=True, raise_if_exists=False):
    method _scp (line 223) | def _scp(self, src, dest):
    method put (line 243) | def put(self, local_path, path):
    method get (line 254) | def get(self, path, local_path):
  class AtomicRemoteFileWriter (line 269) | class AtomicRemoteFileWriter(luigi.format.OutputPipeProcessWrapper):
    method __init__ (line 270) | def __init__(self, fs, path):
    method __del__ (line 283) | def __del__(self):
    method close (line 293) | def close(self):
    method tmp_path (line 298) | def tmp_path(self):
    method fs (line 302) | def fs(self):
  class RemoteTarget (line 306) | class RemoteTarget(luigi.target.FileSystemTarget):
    method __init__ (line 313) | def __init__(self, path, host, format=None, **kwargs):
    method fs (line 321) | def fs(self):
    method open (line 324) | def open(self, mode="r"):
    method put (line 340) | def put(self, local_path):
    method get (line 343) | def get(self, local_path):

FILE: luigi/contrib/target.py
  class CascadingClient (line 26) | class CascadingClient:
    method __init__ (line 55) | def __init__(self, clients, method_names=None):
    method _make_method (line 66) | def _make_method(cls, method_name):
    method _chained_call (line 72) | def _chained_call(self, method_name, *args, **kwargs):

FILE: luigi/contrib/webhdfs.py
  class WebHdfsTarget (line 35) | class WebHdfsTarget(FileSystemTarget):
    method __init__ (line 38) | def __init__(self, path, client=None, format=None):
    method open (line 47) | def open(self, mode="r"):
  class ReadableWebHdfsFile (line 57) | class ReadableWebHdfsFile:
    method __init__ (line 58) | def __init__(self, path, client):
    method read (line 63) | def read(self):
    method readlines (line 68) | def readlines(self, char="\n"):
    method __enter__ (line 72) | def __enter__(self):
    method __exit__ (line 75) | def __exit__(self, exc_type, exc, traceback):
    method __iter__ (line 78) | def __iter__(self):
    method close (line 83) | def close(self):
  class AtomicWebHdfsFile (line 87) | class AtomicWebHdfsFile(AtomicLocalFile):
    method __init__ (line 92) | def __init__(self, path, client):
    method move_to_final_destination (line 96) | def move_to_final_destination(self):

FILE: luigi/date_interval.py
  class DateInterval (line 38) | class DateInterval:
    method __init__ (line 56) | def __init__(self, date_a, date_b):
    method dates (line 60) | def dates(self):
    method hours (line 70) | def hours(self):
    method __str__ (line 76) | def __str__(self):
    method __repr__ (line 79) | def __repr__(self):
    method prev (line 82) | def prev(self):
    method next (line 86) | def next(self):
    method to_string (line 90) | def to_string(self):
    method from_date (line 94) | def from_date(cls, d):
    method parse (line 101) | def parse(cls, s):
    method __contains__ (line 107) | def __contains__(self, date):
    method __iter__ (line 110) | def __iter__(self):
    method __hash__ (line 114) | def __hash__(self):
    method __cmp__ (line 117) | def __cmp__(self, other):
    method __lt__ (line 124) | def __lt__(self, other):
    method __le__ (line 129) | def __le__(self, other):
    method __gt__ (line 134) | def __gt__(self, other):
    method __ge__ (line 139) | def __ge__(self, other):
    method __eq__ (line 144) | def __eq__(self, other):
    method __ne__ (line 152) | def __ne__(self, other):
  class Date (line 156) | class Date(DateInterval):
    method __init__ (line 159) | def __init__(self, y, m, d):
    method to_string (line 164) | def to_string(self):
    method from_date (line 168) | def from_date(cls, d):
    method parse (line 172) | def parse(cls, s):
  class Week (line 177) | class Week(DateInterval):
    method __init__ (line 183) | def __init__(self, y, w):
    method to_string (line 195) | def to_string(self):
    method from_date (line 199) | def from_date(cls, d):
    method parse (line 203) | def parse(cls, s):
  class Month (line 209) | class Month(DateInterval):
    method __init__ (line 210) | def __init__(self, y, m):
    method to_string (line 215) | def to_string(self):
    method from_date (line 219) | def from_date(cls, d):
    method parse (line 223) | def parse(cls, s):
  class Year (line 229) | class Year(DateInterval):
    method __init__ (line 230) | def __init__(self, y):
    method to_string (line 235) | def to_string(self):
    method from_date (line 239) | def from_date(cls, d):
    method parse (line 243) | def parse(cls, s):
  class Custom (line 248) | class Custom(DateInterval):
    method to_string (line 256) | def to_string(self):
    method parse (line 260) | def parse(cls, s):

FILE: luigi/db_task_history.py
  class DbTaskHistory (line 56) | class DbTaskHistory(task_history.TaskHistory):
    method _session (line 65) | def _session(self, session=None):
    method __init__ (line 78) | def __init__(self):
    method task_scheduled (line 88) | def task_scheduled(self, task):
    method task_finished (line 92) | def task_finished(self, task, successful):
    method task_started (line 97) | def task_started(self, task, worker_host):
    method _get_task (line 101) | def _get_task(self, task, status, host=None):
    method _add_task_event (line 111) | def _add_task_event(self, task, event):
    method _find_or_create_task (line 115) | def _find_or_create_task(self, task):
    method find_all_by_parameters (line 133) | def find_all_by_parameters(self, task_name, session=None, **task_params):
    method find_all_by_name (line 150) | def find_all_by_name(self, task_name, session=None):
    method find_latest_runs (line 156) | def find_latest_runs(self, session=None):
    method find_all_runs (line 171) | def find_all_runs(self, session=None):
    method find_all_events (line 178) | def find_all_events(self, session=None):
    method find_task_by_id (line 185) | def find_task_by_id(self, id, session=None):
    method find_task_by_task_id (line 192) | def find_task_by_task_id(self, task_id, session=None):
  class TaskParameter (line 200) | class TaskParameter(Base):  # type: ignore
    method __repr__ (line 210) | def __repr__(self):
  class TaskEvent (line 214) | class TaskEvent(Base):  # type: ignore
    method __repr__ (line 225) | def __repr__(self):
  class TaskRecord (line 229) | class TaskRecord(Base):  # type: ignore
    method __repr__ (line 246) | def __repr__(self):
  function _upgrade_schema (line 250) | def _upgrade_schema(engine):

FILE: luigi/event.py
  class Event (line 21) | class Event:

FILE: luigi/execution_summary.py
  class execution_summary (line 33) | class execution_summary(Config):
  class LuigiStatusCode (line 37) | class LuigiStatusCode(enum.Enum):
  class LuigiRunResult (line 66) | class LuigiRunResult:
    method __init__ (line 79) | def __init__(self, worker, worker_add_run_status=True):
    method __str__ (line 87) | def __str__(self):
    method __repr__ (line 90) | def __repr__(self):
  function _partition_tasks (line 94) | def _partition_tasks(worker):
  function _root_task (line 128) | def _root_task(worker):
  function _populate_unknown_statuses (line 135) | def _populate_unknown_statuses(set_tasks):
  function _depth_first_search (line 144) | def _depth_first_search(set_tasks, current_task, visited):
  function _get_str (line 179) | def _get_str(task_dict, extra_indent):
  function _get_len_of_params (line 242) | def _get_len_of_params(task):
  function _get_str_ranging_multiple_parameters (line 246) | def _get_str_ranging_multiple_parameters(first, last, tasks, unique_param):
  function _get_set_of_params (line 261) | def _get_set_of_params(tasks):
  function _get_unique_param_keys (line 268) | def _get_unique_param_keys(params):
  function _ranging_attributes (line 274) | def _ranging_attributes(attributes, param_class):
  function _get_str_one_parameter (line 288) | def _get_str_one_parameter(tasks):
  function _serialize_first_param (line 303) | def _serialize_first_param(task):
  function _get_number_of_tasks_for (line 307) | def _get_number_of_tasks_for(status, group_tasks):
  function _get_number_of_tasks (line 313) | def _get_number_of_tasks(task_dict):
  function _get_comments (line 317) | def _get_comments(group_tasks):
  function _get_run_by_other_worker (line 363) | def _get_run_by_other_worker(worker):
  function _get_external_workers (line 371) | def _get_external_workers(worker):
  function _group_tasks_by_name_and_status (line 389) | def _group_tasks_by_name_and_status(task_dict):
  function _summary_dict (line 403) | def _summary_dict(worker):
  function _summary_format (line 410) | def _summary_format(set_tasks, worker):
  function _create_one_line_summary (line 460) | def _create_one_line_summary(status_code):
  function _tasks_status (line 467) | def _tasks_status(set_tasks):
  function _summary_wrap (line 488) | def _summary_wrap(str_output):
  function summary (line 498) | def summary(worker):

FILE: luigi/format.py
  class FileWrapper (line 28) | class FileWrapper:
    method __init__ (line 33) | def __init__(self, file_object):
    method __getattr__ (line 36) | def __getattr__(self, name):
    method __enter__ (line 40) | def __enter__(self, *args, **kwargs):
    method __exit__ (line 47) | def __exit__(self, *args, **kwargs):
    method __iter__ (line 50) | def __iter__(self):
  class InputPipeProcessWrapper (line 54) | class InputPipeProcessWrapper:
    method __init__ (line 55) | def __init__(self, command, input_pipe=None):
    method create_subprocess (line 90) | def create_subprocess(self, command):
    method _finish (line 102) | def _finish(self):
    method close (line 117) | def close(self):
    method __del__ (line 120) | def __del__(self):
    method __enter__ (line 123) | def __enter__(self):
    method _abort (line 126) | def _abort(self):
    method __exit__ (line 137) | def __exit__(self, type, value, traceback):
    method __getattr__ (line 143) | def __getattr__(self, name):
    method __iter__ (line 151) | def __iter__(self):
    method readable (line 156) | def readable(self):
    method writable (line 159) | def writable(self):
    method seekable (line 162) | def seekable(self):
  class OutputPipeProcessWrapper (line 166) | class OutputPipeProcessWrapper:
    method __init__ (line 169) | def __init__(self, command, output_pipe=None):
    method write (line 176) | def write(self, *args, **kwargs):
    method writeLine (line 183) | def writeLine(self, line):
    method _finish (line 187) | def _finish(self):
    method __del__ (line 197) | def __del__(self):
    method __exit__ (line 201) | def __exit__(self, type, value, traceback):
    method __enter__ (line 207) | def __enter__(self):
    method close (line 210) | def close(self):
    method abort (line 218) | def abort(self):
    method __getattr__ (line 221) | def __getattr__(self, name):
    method readable (line 229) | def readable(self):
    method writable (line 232) | def writable(self):
    method seekable (line 235) | def seekable(self):
  class BaseWrapper (line 239) | class BaseWrapper:
    method __init__ (line 240) | def __init__(self, stream, *args, **kwargs):
    method __getattr__ (line 247) | def __getattr__(self, name):
    method __enter__ (line 252) | def __enter__(self):
    method __exit__ (line 256) | def __exit__(self, *args):
    method __iter__ (line 259) | def __iter__(self):
  class NewlineWrapper (line 267) | class NewlineWrapper(BaseWrapper):
    method __init__ (line 268) | def __init__(self, stream, newline=None):
    method read (line 278) | def read(self, n=-1):
    method writelines (line 289) | def writelines(self, lines):
    method write (line 297) | def write(self, b):
  class MixedUnicodeBytesWrapper (line 306) | class MixedUnicodeBytesWrapper(BaseWrapper):
    method __init__ (line 309) | def __init__(self, stream, encoding=None):
    method write (line 315) | def write(self, b):
    method writelines (line 318) | def writelines(self, lines):
    method _convert (line 321) | def _convert(self, b):
  class Format (line 328) | class Format:
    method pipe_reader (line 334) | def pipe_reader(cls, input_pipe):
    method pipe_writer (line 338) | def pipe_writer(cls, output_pipe):
    method __rshift__ (line 341) | def __rshift__(a, b):
  class ChainFormat (line 345) | class ChainFormat(Format):
    method __init__ (line 346) | def __init__(self, *args, **kwargs):
    method pipe_reader (line 374) | def pipe_reader(self, input_pipe):
    method pipe_writer (line 379) | def pipe_writer(self, output_pipe):
  class TextWrapper (line 385) | class TextWrapper(io.TextIOWrapper):
    method __exit__ (line 386) | def __exit__(self, *args):
    method __del__ (line 393) | def __del__(self, *args):
    method __init__ (line 403) | def __init__(self, stream, *args, **kwargs):
    method __getattr__ (line 410) | def __getattr__(self, name):
    method __enter__ (line 415) | def __enter__(self):
  class NopFormat (line 420) | class NopFormat(Format):
    method pipe_reader (line 421) | def pipe_reader(self, input_pipe):
    method pipe_writer (line 424) | def pipe_writer(self, output_pipe):
  class WrappedFormat (line 428) | class WrappedFormat(Format):
    method __init__ (line 429) | def __init__(self, *args, **kwargs):
    method pipe_reader (line 433) | def pipe_reader(self, input_pipe):
    method pipe_writer (line 436) | def pipe_writer(self, output_pipe):
  class TextFormat (line 440) | class TextFormat(WrappedFormat):
  class MixedUnicodeBytesFormat (line 446) | class MixedUnicodeBytesFormat(WrappedFormat):
  class NewlineFormat (line 451) | class NewlineFormat(WrappedFormat):
  class GzipFormat (line 457) | class GzipFormat(Format):
    method __init__ (line 461) | def __init__(self, compression_level=None):
    method pipe_reader (line 464) | def pipe_reader(self, input_pipe):
    method pipe_writer (line 467) | def pipe_writer(self, output_pipe):
  class Bzip2Format (line 474) | class Bzip2Format(Format):
    method pipe_reader (line 478) | def pipe_reader(self, input_pipe):
    method pipe_writer (line 481) | def pipe_writer(self, output_pipe):
  function get_default_format (line 494) | def get_default_format():

FILE: luigi/freezing.py
  class FrozenOrderedDict (line 16) | class FrozenOrderedDict(Mapping):
    method __init__ (line 22) | def __init__(self, *args, **kwargs):
    method __getitem__ (line 26) | def __getitem__(self, key):
    method __iter__ (line 29) | def __iter__(self):
    method __len__ (line 32) | def __len__(self):
    method __repr__ (line 35) | def __repr__(self):
    method __hash__ (line 39) | def __hash__(self):
    method get_wrapped (line 46) | def get_wrapped(self):
  function recursively_freeze (line 50) | def recursively_freeze(value):
  function recursively_unfreeze (line 61) | def recursively_unfreeze(value):

FILE: luigi/interface.py
  class core (line 37) | class core(task.Config):
  class _WorkerSchedulerFactory (line 85) | class _WorkerSchedulerFactory:
    method create_local_scheduler (line 86) | def create_local_scheduler(self):
    method create_remote_scheduler (line 89) | def create_remote_scheduler(self, url):
    method create_worker (line 92) | def create_worker(self, scheduler, worker_processes, assistant=False):
  function _schedule_and_run (line 96) | def _schedule_and_run(tasks, worker_scheduler_factory=None, override_def...
  class PidLockAlreadyTakenExit (line 146) | class PidLockAlreadyTakenExit(SystemExit):
  function run (line 154) | def run(*args, **kwargs):
  function _run (line 166) | def _run(cmdline_args=None, main_task_cls=None, worker_scheduler_factory...
  function build (line 180) | def build(tasks, worker_scheduler_factory=None, detailed_summary=False, ...

FILE: luigi/local_target.py
  class atomic_file (line 34) | class atomic_file(AtomicLocalFile):
    method move_to_final_destination (line 39) | def move_to_final_destination(self):
    method generate_tmp_path (line 42) | def generate_tmp_path(self, path):
  class LocalFileSystem (line 46) | class LocalFileSystem(FileSystem):
    method copy (line 53) | def copy(self, old_path, new_path, raise_if_exists=False):
    method exists (line 61) | def exists(self, path):
    method mkdir (line 64) | def mkdir(self, path, parents=True, raise_if_exists=False):
    method isdir (line 85) | def isdir(self, path):
    method listdir (line 88) | def listdir(self, path):
    method remove (line 94) | def remove(self, path, recursive=True):
    method move (line 100) | def move(self, old_path, new_path, raise_if_exists=False):
    method rename_dont_move (line 122) | def rename_dont_move(self, path, dest):
  class LocalTarget (line 131) | class LocalTarget(FileSystemTarget):
    method __init__ (line 134) | def __init__(self, path=None, format=None, is_tmp=False):
    method makedirs (line 146) | def makedirs(self):
    method open (line 158) | def open(self, mode="r"):
    method move (line 171) | def move(self, new_path, raise_if_exists=False):
    method move_dir (line 174) | def move_dir(self, new_path):
    method remove (line 177) | def remove(self):
    method copy (line 180) | def copy(self, new_path, raise_if_exists=False):
    method fn (line 184) | def fn(self):
    method __del__ (line 188) | def __del__(self):

FILE: luigi/lock.py
  function getpcmd (line 30) | def getpcmd(pid):
  function get_info (line 76) | def get_info(pid_dir, my_pid=None):
  function acquire_for (line 88) | def acquire_for(pid_dir, num_available=1, kill_signal=None):
  function _read_pids_file (line 133) | def _read_pids_file(pid_file):
  function _write_pids_file (line 150) | def _write_pids_file(pid_file, pids_set):

FILE: luigi/metrics.py
  class MetricsCollectors (line 6) | class MetricsCollectors(Enum):
    method get (line 14) | def get(cls, which, custom_import=None):
  class MetricsCollector (line 45) | class MetricsCollector(metaclass=abc.ABCMeta):
    method __init__ (line 51) | def __init__(self):
    method handle_task_started (line 55) | def handle_task_started(self, task):
    method handle_task_failed (line 59) | def handle_task_failed(self, task):
    method handle_task_disabled (line 63) | def handle_task_disabled(self, task, config):
    method handle_task_done (line 67) | def handle_task_done(self, task):
    method handle_task_statistics (line 70) | def handle_task_statistics(self, task, statistics):
    method generate_latest (line 73) | def generate_latest(self):
    method configure_http_handler (line 76) | def configure_http_handler(self, http_handler):
  class NoMetricsCollector (line 80) | class NoMetricsCollector(MetricsCollector):
    method __init__ (line 83) | def __init__(self):
    method handle_task_started (line 86) | def handle_task_started(self, task):
    method handle_task_failed (line 89) | def handle_task_failed(self, task):
    method handle_task_disabled (line 92) | def handle_task_disabled(self, task, config):
    method handle_task_done (line 95) | def handle_task_done(self, task):

FILE: luigi/mock.py
  class MockFileSystem (line 31) | class MockFileSystem(target.FileSystem):
    method copy (line 38) | def copy(self, path, dest, raise_if_exists=False):
    method get_all_data (line 47) | def get_all_data(self):
    method get_data (line 53) | def get_data(self, fn):
    method exists (line 56) | def exists(self, path):
    method remove (line 59) | def remove(self, path, recursive=True, skip_trash=True):
    method move (line 73) | def move(self, path, dest, raise_if_exists=False):
    method listdir (line 82) | def listdir(self, path):
    method isdir (line 88) | def isdir(self, path):
    method mkdir (line 91) | def mkdir(self, path, parents=True, raise_if_exists=False):
    method clear (line 97) | def clear(self):
  class MockTarget (line 101) | class MockTarget(target.FileSystemTarget):
    method __init__ (line 104) | def __init__(self, fn, is_tmp=None, mirror_on_stderr=False, format=None):
    method exists (line 109) | def exists(
    method move (line 114) | def move(self, path, raise_if_exists=False):
    method rename (line 120) | def rename(self, *args, **kwargs):
    method open (line 126) | def open(self, mode="r"):

FILE: luigi/mypy.py
  class TaskPlugin (line 63) | class TaskPlugin(Plugin):
    method get_base_class_hook (line 64) | def get_base_class_hook(self, fullname: str) -> Callable[[ClassDefCont...
    method get_function_hook (line 71) | def get_function_hook(self, fullname: str) -> Callable[[FunctionContex...
    method check_parameter (line 77) | def check_parameter(self, fullname):
    method _task_class_maker_callback (line 82) | def _task_class_maker_callback(self, ctx: ClassDefContext) -> None:
    method _infer_choice_enum_element_type (line 86) | def _infer_choice_enum_element_type(self, ctx: FunctionContext, defaul...
    method _task_parameter_field_callback (line 100) | def _task_parameter_field_callback(self, ctx: FunctionContext) -> Type:
  class TaskAttribute (line 162) | class TaskAttribute:
    method __init__ (line 163) | def __init__(
    method to_argument (line 181) | def to_argument(self, current_info: TypeInfo, *, of: Literal["__init__...
    method expand_type (line 193) | def expand_type(self, current_info: TypeInfo) -> Type | None:
    method to_var (line 203) | def to_var(self, current_info: TypeInfo) -> Var:
    method serialize (line 206) | def serialize(self) -> JsonDict:
    method deserialize (line 217) | def deserialize(cls, info: TypeInfo, data: JsonDict, api: SemanticAnal...
    method expand_typevar_from_subtype (line 222) | def expand_typevar_from_subtype(self, sub_type: TypeInfo) -> None:
  class TaskTransformer (line 230) | class TaskTransformer:
    method __init__ (line 233) | def __init__(
    method transform (line 245) | def transform(self) -> bool:
    method _get_assignment_statements_from_if_statement (line 269) | def _get_assignment_statements_from_if_statement(self, stmt: IfStmt) -...
    method _get_assignment_statements_from_block (line 276) | def _get_assignment_statements_from_block(self, block: Block) -> Itera...
    method collect_attributes (line 283) | def collect_attributes(self) -> Optional[List[TaskAttribute]]:
    method _collect_parameter_args (line 393) | def _collect_parameter_args(self, expr: Expression) -> tuple[bool, Dic...
    method _infer_task_attr_init_type (line 413) | def _infer_task_attr_init_type(self, sym: SymbolTableNode, context: Co...
    method is_parameter_call (line 464) | def is_parameter_call(self, expr: Expression) -> bool:
    method _resolve_parameter_type (line 485) | def _resolve_parameter_type(self, t: Instance) -> Type:
  function plugin (line 504) | def plugin(version: str) -> type[Plugin]:

FILE: luigi/notifications.py
  class TestNotificationsTask (line 42) | class TestNotificationsTask(Task):
    method run (line 57) | def run(self):
    method complete (line 60) | def complete(self):
  class email (line 66) | class email(Config):
  class smtp (line 82) | class smtp(Config):
  class sendgrid (line 103) | class sendgrid(Config):
  function generate_email (line 107) | def generate_email(sender, subject, message, recipients, image_png):
  function wrap_traceback (line 129) | def wrap_traceback(traceback):
  function send_email_smtp (line 154) | def send_email_smtp(sender, subject, message, recipients, image_png):
  function send_email_ses (line 181) | def send_email_ses(sender, subject, message, recipients, image_png):
  function send_email_sendgrid (line 205) | def send_email_sendgrid(sender, subject, message, recipients, image_png):
  function _email_disabled_reason (line 223) | def _email_disabled_reason():
  function send_email_sns (line 234) | def send_email_sns(sender, subject, message, topic_ARN, image_png):
  function send_email (line 262) | def send_email(subject, message, sender, recipients, image_png=None):
  function _email_recipients (line 300) | def _email_recipients(additional_recipients=None):
  function send_error_email (line 311) | def send_error_email(subject, message, additional_recipients=None):
  function _prefix (line 320) | def _prefix(subject):
  function format_task_error (line 331) | def format_task_error(headline, task, command, formatted_exception=None):

FILE: luigi/parameter.py
  class _NoValueType (line 65) | class _NoValueType:
    method __new__ (line 70) | def __new__(cls) -> "_NoValueType":
    method __repr__ (line 75) | def __repr__(self) -> str:
  class ParameterVisibility (line 82) | class ParameterVisibility(IntEnum):
    method has_value (line 93) | def has_value(cls, value):
    method serialize (line 96) | def serialize(self):
  class ParameterException (line 100) | class ParameterException(Exception):
  class MissingParameterException (line 108) | class MissingParameterException(ParameterException):
  class UnknownParameterException (line 116) | class UnknownParameterException(ParameterException):
  class DuplicateParameterException (line 124) | class DuplicateParameterException(ParameterException):
  class OptionalParameterTypeWarning (line 132) | class OptionalParameterTypeWarning(UserWarning):
  class UnconsumedParameterWarning (line 140) | class UnconsumedParameterWarning(UserWarning):
  class ConfigPath (line 148) | class ConfigPath(TypedDict):
  class _ParameterKwargs (line 153) | class _ParameterKwargs(TypedDict, total=False):
  class Parameter (line 164) | class Parameter(Generic[T]):
    method __init__ (line 205) | def __init__(
    method __get__ (line 268) | def __get__(self, instance: None, owner: Any) -> "Parameter[T]": ...
    method __get__ (line 271) | def __get__(self, instance: Any, owner: Any) -> T: ...
    method __get__ (line 273) | def __get__(self, instance: Any, owner: Any) -> Any:
    method __set_name__ (line 278) | def __set_name__(self, owner, name):
    method __set__ (line 281) | def __set__(self, instance: Any, value: T):
    method _get_value_from_config (line 286) | def _get_value_from_config(self, section, name):
    method _get_value (line 298) | def _get_value(self, task_name, param_name):
    method _value_iterator (line 306) | def _value_iterator(self, task_name, param_name):
    method has_task_value (line 327) | def has_task_value(self, task_name, param_name):
    method task_value (line 330) | def task_value(self, task_name, param_name):
    method _is_batchable (line 337) | def _is_batchable(self):
    method parse (line 340) | def parse(self, x):
    method _parse_list (line 352) | def _parse_list(self, xs):
    method serialize (line 369) | def serialize(self, x):
    method _warn_on_wrong_param_type (line 379) | def _warn_on_wrong_param_type(self, param_name, param_value):
    method normalize (line 385) | def normalize(self, x):
    method next_in_enumeration (line 399) | def next_in_enumeration(self, value):
    method _parse_or_no_value (line 412) | def _parse_or_no_value(self, x):
    method _parser_global_dest (line 419) | def _parser_global_dest(param_name, task_name):
    method _parser_kwargs (line 423) | def _parser_kwargs(cls, param_name, task_name=None):
  class OptionalParameterMixin (line 430) | class OptionalParameterMixin(Generic[_OptT]):
    method __init__ (line 437) | def __init__(
    method __get__ (line 445) | def __get__(self, instance: None, owner: Any) -> "Parameter[Optional[_...
    method __get__ (line 448) | def __get__(self, instance: Any, owner: Any) -> Optional[_OptT]: ...
    method __get__ (line 450) | def __get__(self, instance: Any, owner: Any) -> Any:
    method __set__ (line 453) | def __set__(self, instance: Any, value: Optional[_OptT]):
    method serialize (line 456) | def serialize(self, x):
    method parse (line 465) | def parse(self, x):
    method normalize (line 476) | def normalize(self, x):
    method _warn_on_wrong_param_type (line 484) | def _warn_on_wrong_param_type(self, param_name, param_value):
    method next_in_enumeration (line 495) | def next_in_enumeration(self, value):
  class OptionalParameter (line 499) | class OptionalParameter(OptionalParameterMixin[str], Parameter[Optional[...
  class OptionalStrParameter (line 505) | class OptionalStrParameter(OptionalParameterMixin[str], Parameter[Option...
  class _DateParameterBase (line 514) | class _DateParameterBase(Parameter[datetime.date]):
    method __init__ (line 519) | def __init__(
    method date_format (line 532) | def date_format(self):
    method parse (line 538) | def parse(self, s):
    method serialize (line 544) | def serialize(self, dt):
  class DateParameter (line 553) | class DateParameter(_DateParameterBase):
    method next_in_enumeration (line 586) | def next_in_enumeration(self, value):
    method normalize (line 589) | def normalize(self, x):
  class MonthParameter (line 600) | class MonthParameter(DateParameter):
    method _add_months (line 612) | def _add_months(self, date, months):
    method next_in_enumeration (line 624) | def next_in_enumeration(self, value):
    method normalize (line 627) | def normalize(self, x):
  class YearParameter (line 640) | class YearParameter(DateParameter):
    method next_in_enumeration (line 651) | def next_in_enumeration(self, value):
    method normalize (line 654) | def normalize(self, x):
  class _DatetimeParameterBase (line 665) | class _DatetimeParameterBase(Parameter[datetime.datetime]):
    method __init__ (line 670) | def __init__(
    method date_format (line 683) | def date_format(self):
    method _timedelta (line 691) | def _timedelta(self):
    method parse (line 697) | def parse(self, s):
    method serialize (line 703) | def serialize(self, dt):
    method _convert_to_dt (line 712) | def _convert_to_dt(dt):
    method normalize (line 717) | def normalize(self, dt):
    method next_in_enumeration (line 732) | def next_in_enumeration(self, value):
  class DateHourParameter (line 736) | class DateHourParameter(_DatetimeParameterBase):
  class DateMinuteParameter (line 749) | class DateMinuteParameter(_DatetimeParameterBase):
    method parse (line 764) | def parse(self, x):
  class DateSecondParameter (line 773) | class DateSecondParameter(_DatetimeParameterBase):
  class StrParameter (line 788) | class StrParameter(Parameter[str]):
    method parse (line 793) | def parse(self, x):
  class IntParameter (line 797) | class IntParameter(Parameter[int]):
    method parse (line 802) | def parse(self, x):
    method next_in_enumeration (line 808) | def next_in_enumeration(self, value):
  class OptionalIntParameter (line 812) | class OptionalIntParameter(OptionalParameterMixin[int], IntParameter):  ...
  class FloatParameter (line 818) | class FloatParameter(Parameter[float]):
    method parse (line 823) | def parse(self, x):
  class OptionalFloatParameter (line 830) | class OptionalFloatParameter(OptionalParameterMixin[float], FloatParamet...
  class BoolParameter (line 836) | class BoolParameter(Parameter[bool]):
    method __init__ (line 870) | def __init__(
    method parse (line 881) | def parse(self, x):
    method normalize (line 893) | def normalize(self, x):
    method _parser_kwargs (line 899) | def _parser_kwargs(self, *args, **kwargs):
  class OptionalBoolParameter (line 911) | class OptionalBoolParameter(OptionalParameterMixin[bool], BoolParameter)...
  class DateIntervalParameter (line 917) | class DateIntervalParameter(Parameter[date_interval.DateInterval]):
    method parse (line 927) | def parse(self, x):
  class TimeDeltaParameter (line 946) | class TimeDeltaParameter(Parameter[datetime.timedelta]):
    method _apply_regex (line 959) | def _apply_regex(self, regex, input):
    method _parseIso8601 (line 974) | def _parseIso8601(self, input):
    method _parseSimple (line 985) | def _parseSimple(self, input):
    method parse (line 992) | def parse(self, x):
    method serialize (line 1010) | def serialize(self, x):
    method _warn_on_wrong_param_type (line 1024) | def _warn_on_wrong_param_type(self, param_name, param_value):
  class TaskParameter (line 1034) | class TaskParameter(Parameter[Type[TaskType]]):
    method parse (line 1053) | def parse(self, x):
    method serialize (line 1059) | def serialize(self, x):
  class EnumParameter (line 1069) | class EnumParameter(Parameter[EnumParameterType]):
    method __init__ (line 1092) | def __init__(
    method parse (line 1104) | def parse(self, x):
    method serialize (line 1110) | def serialize(self, x):
  class EnumListParameter (line 1114) | class EnumListParameter(Parameter[Tuple[EnumParameterType, ...]]):
    method __init__ (line 1141) | def __init__(
    method parse (line 1153) | def parse(self, x):
    method serialize (line 1164) | def serialize(self, x):
  class _DictParamEncoder (line 1168) | class _DictParamEncoder(JSONEncoder):
    method default (line 1173) | def default(self, obj):
  class DictParameter (line 1182) | class DictParameter(Parameter[DictT]):
    method __init__ (line 1266) | def __init__(
    method normalize (line 1280) | def normalize(self, x):
    method parse (line 1293) | def parse(self, x):
    method serialize (line 1309) | def serialize(self, x):
  class OptionalDictParameter (line 1313) | class OptionalDictParameter(OptionalParameterMixin[FrozenOrderedDict], D...
  class ListParameter (line 1322) | class ListParameter(Parameter[ListT]):
    method __init__ (line 1415) | def __init__(
    method normalize (line 1429) | def normalize(self, x):
    method parse (line 1445) | def parse(self, x):
    method serialize (line 1457) | def serialize(self, x):
  class OptionalListParameter (line 1468) | class OptionalListParameter(OptionalParameterMixin[ListT], ListParameter...
  class TupleParameter (line 1474) | class TupleParameter(ListParameter[ListT]):
    method parse (line 1503) | def parse(self, x):
    method _convert_iterable_to_tuple (line 1533) | def _convert_iterable_to_tuple(self, x):
  class OptionalTupleParameter (line 1539) | class OptionalTupleParameter(OptionalParameterMixin[ListT], TupleParamet...
  class NumericalParameter (line 1548) | class NumericalParameter(Parameter[NumericalType]):
    method __init__ (line 1570) | def __init__(
    method parse (line 1625) | def parse(self, x):
  class OptionalNumericalParameter (line 1633) | class OptionalNumericalParameter(OptionalParameterMixin[NumericalType], ...
    method __init__ (line 1636) | def __init__(
  class ChoiceParameter (line 1648) | class ChoiceParameter(Parameter[ChoiceType]):
    method __init__ (line 1673) | def __init__(
    method parse (line 1700) | def parse(self, x):
    method normalize (line 1704) | def normalize(self, x):
  class ChoiceListParameter (line 1711) | class ChoiceListParameter(ChoiceParameter[ChoiceType]):
    method __get__ (line 1741) | def __get__(self, instance: None, owner: Any) -> "Parameter[Tuple[Choi...
    method __get__ (line 1744) | def __get__(self, instance: Any, owner: Any) -> Tuple[ChoiceType, ...]...
    method __get__ (line 1746) | def __get__(self, instance: Any, owner: Any) -> Any:
    method __init__ (line 1749) | def __init__(
    method parse (line 1758) | def parse(self, x):
    method normalize (line 1762) | def normalize(self, x):
    method serialize (line 1768) | def serialize(self, x):
  class OptionalChoiceParameter (line 1772) | class OptionalChoiceParameter(OptionalParameterMixin[ChoiceType], Choice...
    method __init__ (line 1775) | def __init__(
  class PathParameter (line 1786) | class PathParameter(Parameter[Path]):
    method __init__ (line 1816) | def __init__(
    method normalize (line 1833) | def normalize(self, x):
  class OptionalPathParameter (line 1845) | class OptionalPathParameter(OptionalParameter, PathParameter):  # type: ...

FILE: luigi/process.py
  function check_pid (line 30) | def check_pid(pidfile):
  function write_pid (line 41) | def write_pid(pidfile):
  function get_log_format (line 54) | def get_log_format():
  function get_spool_handler (line 58) | def get_spool_handler(filename):
  function _server_already_running (line 70) | def _server_already_running(pidfile):
  function daemonize (line 77) | def daemonize(cmd, pidfile=None, logdir=None, api_port=8082, address=Non...

FILE: luigi/retcodes.py
  class retcode (line 31) | class retcode(luigi.Config):
  function run_with_retcodes (line 66) | def run_with_retcodes(argv):

FILE: luigi/rpc.py
  function _urljoin (line 55) | def _urljoin(base, url):
  class RPCError (line 66) | class RPCError(Exception):
    method __init__ (line 67) | def __init__(self, message, sub_exception=None):
  class _FetcherInterface (line 72) | class _FetcherInterface(metaclass=abc.ABCMeta):
    method fetch (line 74) | def fetch(self, full_url, body, timeout):
    method close (line 78) | def close(self):
  class URLLibFetcher (line 82) | class URLLibFetcher(_FetcherInterface):
    method _create_request (line 85) | def _create_request(self, full_url, body=None):
    method fetch (line 105) | def fetch(self, full_url, body, timeout):
    method close (line 109) | def close(self):
  class RequestsFetcher (line 113) | class RequestsFetcher(_FetcherInterface):
    method __init__ (line 114) | def __init__(self):
    method check_pid (line 121) | def check_pid(self):
    method fetch (line 128) | def fetch(self, full_url, body, timeout):
    method close (line 134) | def close(self):
  class RemoteScheduler (line 138) | class RemoteScheduler:
    method __init__ (line 143) | def __init__(self, url="http://localhost:8082/", connect_timeout=None):
    method close (line 162) | def close(self):
    method _get_retryer (line 165) | def _get_retryer(self):
    method _fetch (line 174) | def _fetch(self, url_suffix, body):
    method _request (line 184) | def _request(self, url, data, attempts=3, allow_null=True):

FILE: luigi/safe_extractor.py
  class SafeExtractor (line 38) | class SafeExtractor:
    method __init__ (line 54) | def __init__(self, path="."):
    method _is_within_directory (line 64) | def _is_within_directory(directory, target):
    method safe_extract (line 80) | def safe_extract(self, tar_path, members=None, *, numeric_owner=False):

FILE: luigi/scheduler.py
  function _get_empty_retry_policy (line 84) | def _get_empty_retry_policy():
  function rpc_method (line 88) | def rpc_method(**request_args):
  class scheduler (line 115) | class scheduler(Config):
    method _get_retry_policy (line 148) | def _get_retry_policy(self):
  function _get_default (line 152) | def _get_default(x, default):
  class OrderedSet (line 159) | class OrderedSet(MutableSet):
    method __init__ (line 166) | def __init__(self, iterable=None):
    method __len__ (line 173) | def __len__(self):
    method __contains__ (line 176) | def __contains__(self, key):
    method add (line 179) | def add(self, key):
    method discard (line 185) | def discard(self, key):
    method __iter__ (line 191) | def __iter__(self):
    method __reversed__ (line 198) | def __reversed__(self):
    method peek (line 205) | def peek(self, last=True):
    method pop (line 211) | def pop(self, last=True):
    method __repr__ (line 216) | def __repr__(self):
    method __eq__ (line 221) | def __eq__(self, other):
  class Task (line 227) | class Task:
    method __init__ (line 228) | def __init__(
    method __repr__ (line 282) | def __repr__(self):
    method set_params (line 285) | def set_params(self, params):
    method is_batchable (line 296) | def is_batchable(self):
    method add_failure (line 302) | def add_failure(self):
    method num_failures (line 313) | def num_failures(self):
    method has_excessive_failures (line 324) | def has_excessive_failures(self):
    method clear_failures (line 336) | def clear_failures(self):
    method pretty_id (line 344) | def pretty_id(self):
  class Worker (line 349) | class Worker:
    method __init__ (line 354) | def __init__(self, worker_id, last_active=None):
    method add_info (line 365) | def add_info(self, info):
    method update (line 368) | def update(self, worker_reference, get_work=False):
    method prune (line 375) | def prune(self, config):
    method get_tasks (line 380) | def get_tasks(self, state, *statuses):
    method is_trivial_worker (line 388) | def is_trivial_worker(self, state):
    method assistant (line 400) | def assistant(self):
    method enabled (line 404) | def enabled(self):
    method state (line 408) | def state(self):
    method add_rpc_message (line 414) | def add_rpc_message(self, name, **kwargs):
    method fetch_rpc_messages (line 418) | def fetch_rpc_messages(self):
    method __str__ (line 423) | def __str__(self):
  class SimpleTaskState (line 427) | class SimpleTaskState:
    method __init__ (line 436) | def __init__(self, state_path):
    method get_state (line 444) | def get_state(self):
    method set_state (line 447) | def set_state(self, state):
    method dump (line 452) | def dump(self):
    method load (line 462) | def load(self):
    method get_active_tasks (line 479) | def get_active_tasks(self):
    method get_active_tasks_by_status (line 482) | def get_active_tasks_by_status(self, *statuses):
    method get_active_task_count_for_status (line 485) | def get_active_task_count_for_status(self, status):
    method get_batch_running_tasks (line 491) | def get_batch_running_tasks(self, batch_id):
    method set_batcher (line 495) | def set_batcher(self, worker_id, family, batcher_args, max_batch_size):
    method get_batcher (line 499) | def get_batcher(self, worker_id, family):
    method num_pending_tasks (line 502) | def num_pending_tasks(self):
    method get_task (line 508) | def get_task(self, task_id, default=None, setdefault=None):
    method has_task (line 516) | def has_task(self, task_id):
    method re_enable (line 519) | def re_enable(self, task, config=None):
    method set_batch_running (line 526) | def set_batch_running(self, task, batch_id, worker_id):
    method set_status (line 533) | def set_status(self, task, new_status, config=None):
    method fail_dead_worker_task (line 586) | def fail_dead_worker_task(self, task, config, assistants):
    method update_status (line 599) | def update_status(self, task, config):
    method may_prune (line 616) | def may_prune(self, task):
    method inactivate_tasks (line 619) | def inactivate_tasks(self, delete_tasks):
    method get_active_workers (line 627) | def get_active_workers(self, last_active_lt=None, last_get_work_gt=None):
    method get_assistants (line 636) | def get_assistants(self, last_active_lt=None):
    method get_worker_ids (line 639) | def get_worker_ids(self):
    method get_worker (line 642) | def get_worker(self, worker_id):
    method inactivate_workers (line 645) | def inactivate_workers(self, delete_workers):
    method _remove_workers_from_tasks (line 651) | def _remove_workers_from_tasks(self, workers, remove_stakeholders=True):
    method disable_workers (line 657) | def disable_workers(self, worker_ids):
    method update_metrics (line 664) | def update_metrics(self, task, config):
  class Scheduler (line 673) | class Scheduler:
    method __init__ (line 680) | def __init__(self, config=None, resources=None, task_history_impl=None...
    method load (line 708) | def load(self):
    method dump (line 711) | def dump(self):
    method prune (line 717) | def prune(self):
    method _prune_workers (line 724) | def _prune_workers(self):
    method _prune_tasks (line 733) | def _prune_tasks(self):
    method _prune_emails (line 746) | def _prune_emails(self):
    method _update_worker (line 750) | def _update_worker(self, worker_id, worker_reference=None, get_work=Fa...
    method _update_priority (line 757) | def _update_priority(self, task, prio, worker):
    method add_task_batcher (line 771) | def add_task_batcher(self, worker, task_family, batched_args, max_batc...
    method forgive_failures (line 775) | def forgive_failures(self, task_id=None):
    method mark_as_done (line 789) | def mark_as_done(self, task_id=None):
    method add_task (line 802) | def add_task(
    method announce_scheduling_failure (line 966) | def announce_scheduling_failure(self, task_name, family, params, expl,...
    method add_worker (line 978) | def add_worker(self, worker, info, **kwargs):
    method disable_worker (line 982) | def disable_worker(self, worker):
    method set_worker_processes (line 986) | def set_worker_processes(self, worker, n):
    method send_scheduler_message (line 990) | def send_scheduler_message(self, worker, task, content):
    method add_scheduler_message_response (line 1000) | def add_scheduler_message_response(self, task_id, message_id, response):
    method get_scheduler_message_response (line 1006) | def get_scheduler_message_response(self, task_id, message_id):
    method has_task_history (line 1014) | def has_task_history(self):
    method is_pause_enabled (line 1018) | def is_pause_enabled(self):
    method is_paused (line 1022) | def is_paused(self):
    method pause (line 1026) | def pause(self):
    method unpause (line 1031) | def unpause(self):
    method update_resources (line 1036) | def update_resources(self, **resources):
    method update_resource (line 1042) | def update_resource(self, resource, amount):
    method _generate_retry_policy (line 1048) | def _generate_retry_policy(self, task_retry_policy_dict):
    method _has_resources (line 1053) | def _has_resources(self, needed_resources, used_resources):
    method _used_resources (line 1063) | def _used_resources(self):
    method _rank (line 1073) | def _rank(self, task):
    method _schedulable (line 1082) | def _schedulable(self, task):
    method _reset_orphaned_batch_running_tasks (line 1091) | def _reset_orphaned_batch_running_tasks(self, worker_id):
    method count_pending (line 1102) | def count_pending(self, worker):
    method get_work (line 1136) | def get_work(self, host=None, assistant=False, current_tasks=None, wor...
    method ping (line 1283) | def ping(self, **kwargs):
    method _upstream_status (line 1288) | def _upstream_status(self, task_id, upstream_status_table):
    method _serialize_task (line 1314) | def _serialize_task(self, task_id, include_deps=True, deps=None):
    method graph (line 1343) | def graph(self, **kwargs):
    method _filter_done (line 1351) | def _filter_done(self, task_ids):
    method _traverse_graph (line 1357) | def _traverse_graph(self, root_task_id, seen=None, dep_func=None, incl...
    method dep_graph (line 1420) | def dep_graph(self, task_id, include_done=True, **kwargs):
    method inverse_dep_graph (line 1427) | def inverse_dep_graph(self, task_id, include_done=True, **kwargs):
    method task_list (line 1438) | def task_list(self, status="", upstream_status="", limit=True, search=...
    method _first_task_display_name (line 1470) | def _first_task_display_name(self, worker):
    method worker_list (line 1478) | def worker_list(self, include_running=True, **kwargs):
    method resource_list (line 1516) | def resource_list(self):
    method resources (line 1534) | def resources(self):
    method task_search (line 1547) | def task_search(self, task_str, **kwargs):
    method re_enable_task (line 1563) | def re_enable_task(self, task_id):
    method fetch_error (line 1572) | def fetch_error(self, task_id, **kwargs):
    method set_task_status_message (line 1587) | def set_task_status_message(self, task_id, status_message):
    method get_task_status_message (line 1596) | def get_task_status_message(self, task_id):
    method set_task_progress_percentage (line 1604) | def set_task_progress_percentage(self, task_id, progress_percentage):
    method get_task_progress_percentage (line 1613) | def get_task_progress_percentage(self, task_id):
    method decrease_running_task_resources (line 1621) | def decrease_running_task_resources(self, task_id, decrease_resources):
    method get_running_task_resources (line 1638) | def get_running_task_resources(self, task_id):
    method _update_task_history (line 1645) | def _update_task_history(self, task, status, host=None):
    method task_history (line 1658) | def task_history(self):
    method update_metrics_task_started (line 1663) | def update_metrics_task_started(self, task):
    method report_task_statistics (line 1667) | def report_task_statistics(self, task_id, statistics):

FILE: luigi/server.py
  class cors (line 59) | class cors(Config):
    method __init__ (line 70) | def __init__(self, *args, **kwargs):
  class RPCHandler (line 75) | class RPCHandler(tornado.web.RequestHandler):
    method __init__ (line 80) | def __init__(self, *args, **kwargs):
    method initialize (line 84) | def initialize(self, scheduler):
    method options (line 87) | def options(self, *args):
    method get (line 94) | def get(self, method):
    method _handle_cors_preflight (line 113) | def _handle_cors_preflight(self):
    method _handle_cors (line 130) | def _handle_cors(self):
    method _set_other_cors_headers (line 145) | def _set_other_cors_headers(self):
  class BaseTaskHistoryHandler (line 155) | class BaseTaskHistoryHandler(tornado.web.RequestHandler):
    method initialize (line 156) | def initialize(self, scheduler):
    method get_template_path (line 159) | def get_template_path(self):
  class AllRunHandler (line 163) | class AllRunHandler(BaseTaskHistoryHandler):
    method get (line 164) | def get(self):
  class SelectedRunHandler (line 173) | class SelectedRunHandler(BaseTaskHistoryHandler):
    method get (line 174) | def get(self, name):
  function from_utc (line 213) | def from_utc(utcTime, fmt=None):
  class RecentRunHandler (line 232) | class RecentRunHandler(BaseTaskHistoryHandler):
    method get (line 233) | def get(self):
  class ByNameHandler (line 239) | class ByNameHandler(BaseTaskHistoryHandler):
    method get (line 240) | def get(self, name):
  class ByIdHandler (line 246) | class ByIdHandler(BaseTaskHistoryHandler):
    method get (line 247) | def get(self, id):
  class ByTaskIdHandler (line 253) | class ByTaskIdHandler(BaseTaskHistoryHandler):
    method get (line 254) | def get(self, task_id):
  class ByParamsHandler (line 260) | class ByParamsHandler(BaseTaskHistoryHandler):
    method get (line 261) | def get(self, name):
  class RootPathHandler (line 269) | class RootPathHandler(BaseTaskHistoryHandler):
    method get (line 270) | def get(self):
    method head (line 279) | def head(self):
  class MetricsHandler (line 285) | class MetricsHandler(tornado.web.RequestHandler):
    method initialize (line 286) | def initialize(self, scheduler):
    method get (line 289) | def get(self):
  function app (line 297) | def app(scheduler):
  function _init_api (line 319) | def _init_api(scheduler, api_port=None, address=None, unix_socket=None):
  function run (line 332) | def run(api_port=8082, address=None, unix_socket=None, scheduler=None):
  function stop (line 375) | def stop():

FILE: luigi/setup_logging.py
  class BaseLogging (line 31) | class BaseLogging:
    method _section (line 35) | def _section(cls, opts):
    method setup (line 47) | def setup(cls, opts=type("opts", (), {"background": None, "logdir": No...
  class DaemonLogging (line 85) | class DaemonLogging(BaseLogging):
    method _cli (line 92) | def _cli(cls, opts):
    method _conf (line 112) | def _conf(cls, opts):
    method _default (line 127) | def _default(cls, opts):
  class InterfaceLogging (line 134) | class InterfaceLogging(BaseLogging):
    method _cli (line 140) | def _cli(cls, opts):
    method _conf (line 144) | def _conf(cls, opts):
    method _default (line 158) | def _default(cls, opts):

FILE: luigi/static/visualiser/js/graph.js
  function nodeFromTask (line 32) | function nodeFromTask(task) {
  function uniqueIndexByProperty (line 48) | function uniqueIndexByProperty(data, propertyName) {
  function createDependencyEdges (line 57) | function createDependencyEdges(nodes, nodeIndex) {
  function computeDepth (line 72) | function computeDepth(nodes, nodeIndex) {
  function groupTasks (line 93) | function groupTasks(nodes) {
  function computeRows (line 131) | function computeRows(nodes, nodeIndex) {
  function layoutNodes (line 165) | function layoutNodes(nodes, rowSizes) {
  function createGraph (line 190) | function createGraph(tasks, hashBase) {
  function findBounds (line 213) | function findBounds(nodes) {
  function DependencyGraph (line 228) | function DependencyGraph(containerElement) {
  function svgElement (line 235) | function svgElement(name) {
  function svgLink (line 239) | function svgLink(url) {

FILE: luigi/static/visualiser/js/luigi.js
  function LuigiAPI (line 2) | function LuigiAPI (urlRoot) {
  function flatten (line 6) | function flatten(response, rootId) {
  function flatten_running (line 22) | function flatten_running(response) {
  function jsonRPC (line 29) | function jsonRPC(url, paramObject, callback) {
  function searchTerm (line 38) | function searchTerm() {

FILE: luigi/static/visualiser/js/tipsy.js
  function maybeCall (line 8) | function maybeCall(thing, ctx) {
  function Tipsy (line 12) | function Tipsy(element, options) {
  function get (line 180) | function get(ele) {
  function enter (line 189) | function enter() {
  function leave (line 200) | function leave() {

FILE: luigi/static/visualiser/js/util.js
  function escapeHtml (line 1) | function escapeHtml(unsafe) {

FILE: luigi/static/visualiser/js/visualiserApp.js
  function visualiserApp (line 1) | function visualiserApp(luigi) {

FILE: luigi/static/visualiser/lib/URI/1.18.2/URI.js
  function URI (line 35) | function URI(url, base) {
  function escapeRegEx (line 79) | function escapeRegEx(string) {
  function getType (line 84) | function getType(value) {
  function isArray (line 93) | function isArray(obj) {
  function filterArrayValues (line 97) | function filterArrayValues(data, value) {
  function arrayContains (line 126) | function arrayContains(list, value) {
  function arraysEqual (line 155) | function arraysEqual(one, two) {
  function trimSlashes (line 177) | function trimSlashes(text) {
  function escapeForDumbFirefox36 (line 271) | function escapeForDumbFirefox36(value) {
  function strictEncodeURIComponent (line 277) | function strictEncodeURIComponent(string) {
  function generateSimpleAccessor (line 1048) | function generateSimpleAccessor(_part){
  function generatePrefixAccessor (line 1060) | function generatePrefixAccessor(_part, _key){

FILE: luigi/static/visualiser/lib/mustache.js
  function testRegExp (line 32) | function testRegExp(re, string) {
  function isWhitespace (line 36) | function isWhitespace(string) {
  function escapeRegExp (line 45) | function escapeRegExp(string) {
  function escapeHtml (line 58) | function escapeHtml(string) {
  function Scanner (line 64) | function Scanner(string) {
  function Context (line 118) | function Context(view, parent) {
  function Writer (line 166) | function Writer() {
  function renderTokens (line 227) | function renderTokens(tokens, writer, context, template) {
  function nestTokens (line 295) | function nestTokens(tokens) {
  function squashTokens (line 327) | function squashTokens(tokens) {
  function escapeTags (line 347) | function escapeTags(tags) {
  function parseTemplate (line 360) | function parseTemplate(template, tags) {

FILE: luigi/target.py
  class Target (line 34) | class Target(metaclass=abc.ABCMeta):
    method exists (line 47) | def exists(self):
  class FileSystemException (line 54) | class FileSystemException(Exception):
  class FileAlreadyExists (line 62) | class FileAlreadyExists(FileSystemException):
  class MissingParentDirectory (line 71) | class MissingParentDirectory(FileSystemException):
  class NotADirectory (line 80) | class NotADirectory(FileSystemException):
  class FileSystem (line 89) | class FileSystem(metaclass=abc.ABCMeta):
    method exists (line 102) | def exists(self, path):
    method remove (line 111) | def remove(self, path, recursive=True, skip_trash=True):
    method mkdir (line 120) | def mkdir(self, path, parents=True, raise_if_exists=False):
    method isdir (line 136) | def isdir(self, path):
    method listdir (line 146) | def listdir(self, path):
    method move (line 158) | def move(self, path, dest):
    method rename_dont_move (line 164) | def rename_dont_move(self, path, dest):
    method rename (line 178) | def rename(self, *args, **kwargs):
    method copy (line 184) | def copy(self, path, dest):
  class FileSystemTarget (line 193) | class FileSystemTarget(Target):
    method __init__ (line 212) | def __init__(self, path):
    method __str__ (line 221) | def __str__(self):
    method fs (line 226) | def fs(self):
    method open (line 233) | def open(self, mode):
    method exists (line 247) | def exists(self):
    method remove (line 258) | def remove(self):
    method temporary_path (line 267) | def temporary_path(self):
    method _touchz (line 304) | def _touchz(self):
    method _trailing_slash (line 308) | def _trailing_slash(self):
  class AtomicLocalFile (line 314) | class AtomicLocalFile(io.BufferedWriter):
    method __init__ (line 323) | def __init__(self, path):
    method close (line 328) | def close(self):
    method generate_tmp_path (line 332) | def generate_tmp_path(self, path):
    method move_to_final_destination (line 335) | def move_to_final_destination(self):
    method __del__ (line 338) | def __del__(self):
    method tmp_path (line 343) | def tmp_path(self):
    method __exit__ (line 346) | def __exit__(self, exc_type, exc, traceback):

FILE: luigi/task.py
  function namespace (line 53) | def namespace(namespace=None, scope=""):
  function auto_namespace (line 88) | def auto_namespace(scope=""):
  function task_id_str (line 118) | def task_id_str(task_family, params):
  class BulkCompleteNotImplementedError (line 137) | class BulkCompleteNotImplementedError(NotImplementedError):
  class Task (line 149) | class Task(metaclass=Register):
    method batchable (line 196) | def batchable(self):
    method retry_count (line 204) | def retry_count(self):
    method disable_hard_timeout (line 212) | def disable_hard_timeout(self):
    method disable_window (line 220) | def disable_window(self):
    method disable_window_seconds (line 228) | def disable_window_seconds(self):
    method owner_email (line 233) | def owner_email(self):
    method _owner_list (line 241) | def _owner_list(self):
    method use_cmdline_section (line 254) | def use_cmdline_section(self):
    method event_handler (line 260) | def event_handler(cls, event):
    method remove_event_handler (line 272) | def remove_event_handler(cls, event, callback):
    method trigger_event (line 278) | def trigger_event(self, event, *args, **kwargs):
    method accepts_messages (line 295) | def accepts_messages(self):
    method task_module (line 303) | def task_module(self):
    method get_task_namespace (line 328) | def get_task_namespace(cls):
    method task_family (line 341) | def task_family(self):
    method get_task_family (line 352) | def get_task_family(cls):
    method get_params (line 367) | def get_params(cls):
    method batch_param_names (line 385) | def batch_param_names(cls):
    method get_param_names (line 389) | def get_param_names(cls, include_significant=False):
    method get_param_values (line 393) | def get_param_values(cls, params, args, kwargs):
    method __init__ (line 465) | def __init__(self, *args, **kwargs):
    method param_args (line 485) | def param_args(self):
    method initialized (line 489) | def initialized(self):
    method _warn_on_wrong_param_types (line 495) | def _warn_on_wrong_param_types(self):
    method from_str_params (line 501) | def from_str_params(cls, params_str):
    method to_str_params (line 518) | def to_str_params(self, only_significant=False, only_public=False):
    method _get_param_visibilities (line 534) | def _get_param_visibilities(self):
    method clone (line 543) | def clone(self, cls=None, **kwargs):
    method __hash__ (line 568) | def __hash__(self):
    method __repr__ (line 571) | def __repr__(self):
    method __eq__ (line 589) | def __eq__(self, other):
    method complete (line 592) | def complete(self):
    method bulk_complete (line 607) | def bulk_complete(cls, parameter_tuples):
    method output (line 616) | def output(self):
    method requires (line 634) | def requires(self):
    method _requires (line 648) | def _requires(self):
    method process_resources (line 660) | def process_resources(self):
    method input (line 668) | def input(self):
    method deps (line 679) | def deps(self):
    method run (line 688) | def run(self):
    method on_failure (line 696) | def on_failure(self, exception):
    method on_success (line 711) | def on_success(self):
    method no_unpicklable_properties (line 723) | def no_unpicklable_properties(self):
  class MixinNaiveBulkComplete (line 754) | class MixinNaiveBulkComplete:
    method bulk_complete (line 764) | def bulk_complete(cls, parameter_tuples):
  class DynamicRequirements (line 779) | class DynamicRequirements(object):
    method __init__ (line 815) | def __init__(self, requirements, custom_complete=None):
    method flat_requirements (line 827) | def flat_requirements(self):
    method paths (line 833) | def paths(self):
    method complete (line 838) | def complete(self, complete_fn=None):
  class ExternalTask (line 853) | class ExternalTask(Task):
  function externalize (line 865) | def externalize(taskclass_or_taskobject):
  class WrapperTask (line 926) | class WrapperTask(Task):
    method complete (line 931) | def complete(self):
  class Config (line 935) | class Config(Task):
  function getpaths (line 945) | def getpaths(struct):
  function flatten (line 963) | def flatten(struct):
  function flatten_output (line 999) | def flatten_output(task):
  function _task_wraps (line 1017) | def _task_wraps(task_class):

FILE: luigi/task_history.py
  class StoredTask (line 28) | class StoredTask:
    method __init__ (line 36) | def __init__(self, task, status, host=None):
    method task_family (line 43) | def task_family(self):
    method parameters (line 47) | def parameters(self):
  class TaskHistory (line 51) | class TaskHistory(metaclass=abc.ABCMeta):
    method task_scheduled (line 57) | def task_scheduled(self, task):
    method task_finished (line 61) | def task_finished(self, task, successful):
    method task_started (line 65) | def task_started(self, task, worker_host):
  class NopHistory (line 71) | class NopHistory(TaskHistory):
    method task_scheduled (line 72) | def task_scheduled(self, task):
    method task_finished (line 75) | def task_finished(self, task, successful):
    method task_started (line 78) | def task_started(self, task, worker_host):

FILE: luigi/task_register.py
  class TaskClassException (line 28) | class TaskClassException(Exception):
  class TaskClassNotFoundException (line 32) | class TaskClassNotFoundException(TaskClassException):
  class TaskClassAmbigiousException (line 36) | class TaskClassAmbigiousException(TaskClassException):
  class Register (line 40) | class Register(abc.ABCMeta):
    method __new__ (line 59) | def __new__(metacls, classname, bases, classdict, **kwargs):
    method __call__ (line 73) | def __call__(cls, *args, **kwargs):
    method clear_instance_cache (line 106) | def clear_instance_cache(cls):
    method disable_instance_cache (line 113) | def disable_instance_cache(cls):
    method task_family (line 120) | def task_family(cls):
    method _get_reg (line 131) | def _get_reg(cls):
    method _set_reg (line 157) | def _set_reg(cls, reg):
    method task_names (line 162) | def task_names(cls):
    method tasks_str (line 169) | def tasks_str(cls):
    method get_task_cls (line 176) | def get_task_cls(cls, name):
    method get_all_params (line 189) | def get_all_params(cls):
    method _editdistance (line 202) | def _editdistance(a, b):
    method _missing_task_msg (line 219) | def _missing_task_msg(cls, task_name):
    method _get_namespace (line 229) | def _get_namespace(mcs, module_name):
    method _module_parents (line 237) | def _module_parents(module_name):
  function load_task (line 249) | def load_task(module, task_name, params_str):

FILE: luigi/tools/deps.py
  function get_task_requires (line 52) | def get_task_requires(task):
  function dfs_paths (line 56) | def dfs_paths(start_task, goal_task_family, path=None):
  class upstream (line 67) | class upstream(luigi.task.Config):
  function find_deps (line 75) | def find_deps(task, upstream_task_family):
  function find_deps_cli (line 85) | def find_deps_cli():
  function get_task_output_description (line 94) | def get_task_output_description(task_output):
  function main (line 114) | def main():

FILE: luigi/tools/deps_tree.py
  class bcolors (line 33) | class bcolors:
  function print_tree (line 43) | def print_tree(task, indent="", last=True):
  function main (line 68) | def main():

FILE: luigi/tools/luigi_grep.py
  class LuigiGrep (line 9) | class LuigiGrep:
    method __init__ (line 10) | def __init__(self, host, port):
    method graph_url (line 15) | def graph_url(self):
    method _fetch_json (line 18) | def _fetch_json(self):
    method _build_results (line 24) | def _build_results(self, jobs, job):
    method prefix_search (line 35) | def prefix_search(self, job_name_prefix):
    method status_search (line 43) | def status_search(self, status):
  function main (line 53) | def main():

FILE: luigi/tools/range.py
  class RangeEvent (line 47) | class RangeEvent(luigi.Event):  # Not sure if subclassing currently serv...
  class RangeBase (line 71) | class RangeBase(luigi.WrapperTask):
    method of_cls (line 114) | def of_cls(self):
    method datetime_to_parameter (line 124) | def datetime_to_parameter(self, dt):
    method parameter_to_datetime (line 127) | def parameter_to_datetime(self, p):
    method datetime_to_parameters (line 130) | def datetime_to_parameters(self, dt):
    method parameters_to_datetime (line 136) | def parameters_to_datetime(self, p):
    method moving_start (line 142) | def moving_start(self, now):
    method moving_stop (line 149) | def moving_stop(self, now):
    method finite_datetimes (line 156) | def finite_datetimes(self, finite_start, finite_stop):
    method _emit_metrics (line 163) | def _emit_metrics(self, missing_datetimes, finite_start, finite_stop):
    method _format_datetime (line 183) | def _format_datetime(self, dt):
    method _format_range (line 186) | def _format_range(self, datetimes):
    method _instantiate_task_cls (line 191) | def _instantiate_task_cls(self, param):
    method _param_name (line 195) | def _param_name(self):
    method _task_parameters (line 201) | def _task_parameters(self, param):
    method requires (line 206) | def requires(self):
    method missing_datetimes (line 254) | def missing_datetimes(self, finite_datetimes):
    method _missing_datetimes (line 266) | def _missing_datetimes(self, finite_datetimes):
  class RangeDailyBase (line 280) | class RangeDailyBase(RangeBase):
    method datetime_to_parameter (line 304) | def datetime_to_parameter(self, dt):
    method parameter_to_datetime (line 307) | def parameter_to_datetime(self, p):
    method datetime_to_parameters (line 310) | def datetime_to_parameters(self, dt):
    method parameters_to_datetime (line 316) | def parameters_to_datetime(self, p):
    method moving_start (line 323) | def moving_start(self, now):
    method moving_stop (line 326) | def moving_stop(self, now):
    method finite_datetimes (line 329) | def finite_datetimes(self, finite_start, finite_stop):
  class RangeHourlyBase (line 343) | class RangeHourlyBase(RangeBase):
    method datetime_to_parameter (line 368) | def datetime_to_parameter(self, dt):
    method parameter_to_datetime (line 371) | def parameter_to_datetime(self, p):
    method datetime_to_parameters (line 374) | def datetime_to_parameters(self, dt):
    method parameters_to_datetime (line 380) | def parameters_to_datetime(self, p):
    method moving_start (line 386) | def moving_start(self, now):
    method moving_stop (line 389) | def moving_stop(self, now):
    method finite_datetimes (line 392) | def finite_datetimes(self, finite_start, finite_stop):
    method _format_datetime (line 405) | def _format_datetime(self, dt):
  class RangeByMinutesBase (line 409) | class RangeByMinutesBase(RangeBase):
    method datetime_to_parameter (line 437) | def datetime_to_parameter(self, dt):
    method parameter_to_datetime (line 440) | def parameter_to_datetime(self, p):
    method datetime_to_parameters (line 443) | def datetime_to_parameters(self, dt):
    method parameters_to_datetime (line 449) | def parameters_to_datetime(self, p):
    method moving_start (line 456) | def moving_start(self, now):
    method moving_stop (line 459) | def moving_stop(self, now):
    method finite_datetimes (line 462) | def finite_datetimes(self, finite_start, finite_stop):
    method _format_datetime (line 482) | def _format_datetime(self, dt):
  function _constrain_glob (line 486) | def _constrain_glob(glob, paths, limit=5):
  function most_common (line 526) | def most_common(items):
  function _get_per_location_glob (line 531) | def _get_per_location_glob(tasks, outputs, regexes):
  function _get_filesystems_and_globs (line 562) | def _get_filesystems_and_globs(datetime_to_task, datetime_to_re):
  function _list_existing (line 592) | def _list_existing(filesystem, glob, paths):
  function infer_bulk_complete_from_fs (line 610) | def infer_bulk_complete_from_fs(datetimes, datetime_to_task, datetime_to...
  class RangeMonthly (line 638) | class RangeMonthly(RangeBase):
    method datetime_to_parameter (line 666) | def datetime_to_parameter(self, dt):
    method parameter_to_datetime (line 669) | def parameter_to_datetime(self, p):
    method datetime_to_parameters (line 672) | def datetime_to_parameters(self, dt):
    method parameters_to_datetime (line 678) | def parameters_to_datetime(self, p):
    method _format_datetime (line 685) | def _format_datetime(self, dt):
    method moving_start (line 688) | def moving_start(self, now):
    method moving_stop (line 691) | def moving_stop(self, now):
    method _align (line 694) | def _align(self, dt):
    method finite_datetimes (line 697) | def finite_datetimes(self, finite_start, finite_stop):
  class RangeDaily (line 712) | class RangeDaily(RangeDailyBase):
    method missing_datetimes (line 726) | def missing_datetimes(self, finite_datetimes):
  class RangeHourly (line 737) | class RangeHourly(RangeHourlyBase):
    method missing_datetimes (line 753) | def missing_datetimes(self, finite_datetimes):
  class RangeByMinutes (line 765) | class RangeByMinutes(RangeByMinutesBase):
    method missing_datetimes (line 781) | def missing_datetimes(self, finite_datetimes):

FILE: luigi/util.py
  function common_params (line 228) | def common_params(task_instance, task_cls):
  class inherits (line 245) | class inherits:
    method __init__ (line 280) | def __init__(self, *tasks_to_inherit, **kw_tasks_to_inherit):
    method __call__ (line 289) | def __call__(self, task_that_inherits):
  class requires (line 323) | class requires:
    method __init__ (line 331) | def __init__(self, *tasks_to_require, **kw_tasks_to_require):
    method __call__ (line 337) | def __call__(self, task_that_requires):
  class copies (line 351) | class copies:
    method __init__ (line 365) | def __init__(self, task_to_copy):
    method __call__ (line 369) | def __call__(self, task_that_copies):
  function delegates (line 385) | def delegates(task_that_delegates):
  function previous (line 426) | def previous(task):
  function get_previous_completed (line 464) | def get_previous_completed(task, max_steps=10):

FILE: luigi/worker.py
  function _is_external (line 77) | def _is_external(task):
  function _get_retry_policy_dict (line 81) | def _get_retry_policy_dict(task):
  class TaskException (line 85) | class TaskException(Exception):
  class TaskProcess (line 102) | class TaskProcess(multiprocessing.Process):
    method __init__ (line 117) | def __init__(
    method _run_get_new_deps (line 144) | def _run_get_new_deps(self):
    method run (line 172) | def run(self):
    method _handle_run_exception (line 246) | def _handle_run_exception(self, ex):
    method _recursive_terminate (line 251) | def _recursive_terminate(self):
    method terminate (line 271) | def terminate(self):
    method _forward_attributes (line 280) | def _forward_attributes(self):
  class ContextManagedTaskProcess (line 294) | class ContextManagedTaskProcess(TaskProcess):
    method __init__ (line 295) | def __init__(self, context, *args, **kwargs):
    method run (line 299) | def run(self):
  class TaskStatusReporter (line 312) | class TaskStatusReporter:
    method __init__ (line 320) | def __init__(self, scheduler, task_id, worker_id, scheduler_messages):
    method update_tracking_url (line 326) | def update_tracking_url(self, tracking_url):
    method update_status_message (line 329) | def update_status_message(self, message):
    method update_progress_percentage (line 332) | def update_progress_percentage(self, percentage):
    method decrease_running_resources (line 335) | def decrease_running_resources(self, decrease_resources):
    method report_task_statistics (line 338) | def report_task_statistics(self, statistics):
  class SchedulerMessage (line 342) | class SchedulerMessage:
    method __init__ (line 348) | def __init__(self, scheduler, task_id, message_id, content, **payload):
    method __str__ (line 358) | def __str__(self):
    method __eq__ (line 361) | def __eq__(self, other):
    method respond (line 364) | def respond(self, response):
  class SingleProcessPool (line 368) | class SingleProcessPool:
    method apply_async (line 375) | def apply_async(self, function, args):
    method close (line 378) | def close(self):
    method join (line 381) | def join(self):
  class DequeQueue (line 385) | class DequeQueue(collections.deque):
    method put (line 390) | def put(self, obj, block=None, timeout=None):
    method get (line 393) | def get(self, block=None, timeout=None):
  class AsyncCompletionException (line 400) | class AsyncCompletionException(Exception):
    method __init__ (line 405) | def __init__(self, trace):
  class TracebackWrapper (line 409) | class TracebackWrapper:
    method __init__ (line 414) | def __init__(self, trace):
  function check_complete_cached (line 418) | def check_complete_cached(task, completion_cache=None):
  function check_complete (line 434) | def check_complete(task, out_queue, completion_cache=None):
  class worker (line 446) | class worker(Config):
  class KeepAliveThread (line 498) | class KeepAliveThread(threading.Thread):
    method __init__ (line 503) | def __init__(self, scheduler, worker_id, ping_interval, rpc_message_ca...
    method stop (line 511) | def stop(self):
    method run (line 514) | def run(self):
  function rpc_message_callback (line 533) | def rpc_message_callback(fn):
  class Worker (line 538) | class Worker:
    method __init__ (line 548) | def __init__(self, scheduler=None, worker_id=None, worker_processes=1,...
    method _add_task (line 603) | def _add_task(self, *args, **kwargs):
    method __enter__ (line 627) | def __enter__(self):
    method __exit__ (line 636) | def __exit__(self, type, value, traceback):
    method _generate_worker_info (line 648) | def _generate_worker_info(self):
    method _generate_worker_id (line 672) | def _generate_worker_id(self, worker_info):
    method _validate_task (line 676) | def _validate_task(self, task):
    method _log_complete_error (line 684) | def _log_complete_error(self, task, tb):
    method _log_dependency_error (line 688) | def _log_dependency_error(self, task, tb):
    method _log_unexpected_error (line 692) | def _log_unexpected_error(self, task):
    method _announce_scheduling_failure (line 695) | def _announce_scheduling_failure(self, task, expl):
    method _email_complete_error (line 710) | def _email_complete_error(self, task, formatted_traceback):
    method _email_dependency_error (line 720) | def _email_dependency_error(self, task, formatted_traceback):
    method _email_unexpected_error (line 730) | def _email_unexpected_error(self, task, formatted_traceback):
    method _email_task_failure (line 741) | def _email_task_failure(self, task, formatted_traceback):
    method _email_error (line 750) | def _email_error(self, task, formatted_traceback, subject, headline):
    method _handle_task_load_error (line 757) | def _handle_task_load_error(self, exception, task_ids):
    method add (line 772) | def add(self, task, multiprocess=False, processes=0):
    method _add_task_batcher (line 818) | def _add_task_batcher(self, task):
    method _add (line 832) | def _add(self, task, is_complete):
    method _validate_dependency (line 917) | def _validate_dependency(self, dependency):
    method _check_complete_value (line 923) | def _check_complete_value(self, is_complete):
    method _add_worker (line 929) | def _add_worker(self):
    method _log_remote_tasks (line 933) | def _log_remote_tasks(self, get_work_response):
    method _get_work_task_id (line 946) | def _get_work_task_id(self, get_work_response):
    method _get_work (line 974) | def _get_work(self):
    method _run_task (line 1026) | def _run_task(self, task_id):
    method _create_task_process (line 1045) | def _create_task_process(self, task):
    method _purge_children (line 1062) | def _purge_children(self):
    method _handle_next_task (line 1082) | def _handle_next_task(self):
    method _sleeper (line 1150) | def _sleeper(self):
    method _keep_alive (line 1159) | def _keep_alive(self, get_work_response):
    method handle_interrupt (line 1189) | def handle_interrupt(self, signum, _):
    method _start_phasing_out (line 1196) | def _start_phasing_out(self):
    method run (line 1204) | def run(self):
    method _handle_rpc_message (line 1249) | def _handle_rpc_message(self, message):
    method set_worker_processes (line 1269) | def set_worker_processes(self, n):
    method dispatch_scheduler_message (line 1277) | def dispatch_scheduler_message(self, task_id, message_id, content, **k...

FILE: test/_mysqldb_test.py
  function _create_test_database (line 31) | def _create_test_database():
  class MySqlTargetTest (line 40) | class MySqlTargetTest(unittest.TestCase):
    method test_touch_and_exists (line 41) | def test_touch_and_exists(self):
  function drop (line 48) | def drop():

FILE: test/_test_ftp.py
  class TestFTPFilesystem (line 46) | class TestFTPFilesystem(unittest.TestCase):
    method setUp (line 47) | def setUp(self):
    method test_file_remove (line 73) | def test_file_remove(self):
    method test_recursive_remove (line 87) | def test_recursive_remove(self):
  class TestFTPFilesystemUpload (line 98) | class TestFTPFilesystemUpload(unittest.TestCase):
    method test_single (line 99) | def test_single(self):
  class TestRemoteTarget (line 127) | class TestRemoteTarget(unittest.TestCase):
    method test_put (line 128) | def test_put(self):
    method test_get (line 155) | def test_get(self):
  function _run_ftp_server (line 209) | def _run_ftp_server():

FILE: test/auto_namespace_test/my_namespace_test.py
  class MyNamespaceTest (line 6) | class MyNamespaceTest(LuigiTestCase):
    method test_auto_namespace_scope (line 7) | def test_auto_namespace_scope(self):

FILE: test/batch_notifier_test.py
  class BatchNotifier (line 16) | class BatchNotifier(luigi.batch_notifier.BatchNotifier):
    method __init__ (line 19) | def __init__(self, **kwargs):
  class BatchNotifierTest (line 25) | class BatchNotifierTest(unittest.TestCase):
    method setUp (line 26) | def setUp(self):
    method tearDown (line 39) | def tearDown(self):
    method incr_time (line 44) | def incr_time(self, minutes):
    method check_email_send (line 47) | def check_email_send(self, subject, message, receiver="r@test.com", se...
    method test_send_single_failure (line 50) | def test_send_single_failure(self):
    method test_do_not_send_single_failure_without_receiver (line 56) | def test_do_not_send_single_failure_without_receiver(self):
    method test_send_single_failure_to_owner_only (line 63) | def test_send_single_failure_to_owner_only(self):
    method test_send_single_disable (line 74) | def test_send_single_disable(self):
    method test_send_multiple_disables (line 82) | def test_send_multiple_disables(self):
    method test_send_single_scheduling_fail (line 92) | def test_send_single_scheduling_fail(self):
    method test_multiple_failures_of_same_job (line 101) | def test_multiple_failures_of_same_job(self):
    method test_multiple_failures_of_multiple_jobs (line 109) | def test_multiple_failures_of_multiple_jobs(self):
    method test_group_on_family (line 117) | def test_group_on_family(self):
    method test_group_on_unbatched_params (line 126) | def test_group_on_unbatched_params(self):
    method test_include_one_expl_includes_latest (line 144) | def test_include_one_expl_includes_latest(self):
    method test_include_two_expls (line 153) | def test_include_two_expls(self):
    method test_limit_expl_length (line 164) | def test_limit_expl_length(self):
    method test_expl_varies_by_owner (line 170) | def test_expl_varies_by_owner(self):
    method test_include_two_expls_html_format (line 197) | def test_include_two_expls_html_format(self):
    method test_limit_expl_length_html_format (line 210) | def test_limit_expl_length_html_format(self):
    method test_send_clears_backlog (line 217) | def test_send_clears_backlog(self):
    method test_email_gets_cleared_on_failure (line 228) | def test_email_gets_cleared_on_failure(self):
    method test_send_clears_all_old_data (line 239) | def test_send_clears_all_old_data(self):
    method test_auto_send_on_update_after_time_period (line 253) | def test_auto_send_on_update_after_time_period(self):
    method test_auto_send_on_update_after_time_period_with_disable_only (line 265) | def test_auto_send_on_update_after_time_period_with_disable_only(self):
    method test_no_auto_send_until_end_of_interval_with_error (line 277) | def test_no_auto_send_until_end_of_interval_with_error(self):
    method test_no_auto_send_for_interval_after_exception (line 294) | def test_no_auto_send_for_interval_after_exception(self):
    method test_send_batch_failure_emails_to_owners (line 313) | def test_send_batch_failure_emails_to_owners(self):
    method test_send_batch_disable_email_to_owners (line 342) | def test_send_batch_disable_email_to_owners(self):
    method test_batch_identical_expls (line 363) | def test_batch_identical_expls(self):
    method test_batch_identical_expls_html (line 376) | def test_batch_identical_expls_html(self):
    method test_unicode_error_message (line 397) | def test_unicode_error_message(self):
    method test_unicode_error_message_html (line 403) | def test_unicode_error_message_html(self):
    method test_unicode_param_value (line 410) | def test_unicode_param_value(self):
    method test_unicode_param_value_html (line 418) | def test_unicode_param_value_html(self):
    method test_unicode_param_name (line 427) | def test_unicode_param_name(self):
    method test_unicode_param_name_html (line 435) | def test_unicode_param_name_html(self):
    method test_unicode_class_name (line 444) | def test_unicode_class_name(self):
    method test_unicode_class_name_html (line 450) | def test_unicode_class_name_html(self):

FILE: test/choice_parameter_test.py
  class ChoiceParameterTest (line 23) | class ChoiceParameterTest(unittest.TestCase):
    method test_parse_str (line 24) | def test_parse_str(self):
    method test_parse_int (line 28) | def test_parse_int(self):
    method test_parse_int_conv (line 32) | def test_parse_int_conv(self):
    method test_invalid_choice (line 36) | def test_invalid_choice(self):
    method test_invalid_choice_type (line 40) | def test_invalid_choice_type(self):
    method test_choices_parameter_exception (line 43) | def test_choices_parameter_exception(self):
    method test_hash_str (line 46) | def test_hash_str(self):
    method test_serialize_parse (line 53) | def test_serialize_parse(self):
    method test_invalid_choice_task (line 58) | def test_invalid_choice_task(self):

FILE: test/clone_test.py
  class LinearSum (line 26) | class LinearSum(luigi.Task):
    method requires (line 30) | def requires(self):
    method run (line 34) | def run(self):
    method complete (line 41) | def complete(self):
    method f (line 44) | def f(self, x):
  class PowerSum (line 48) | class PowerSum(LinearSum):
    method f (line 51) | def f(self, x):
  class CloneTest (line 55) | class CloneTest(unittest.TestCase):
    method test_args (line 56) | def test_args(self):
    method test_recursion (line 61) | def test_recursion(self):
    method test_inheritance (line 66) | def test_inheritance(self):
    method test_inheritance_from_non_parameter (line 71) | def test_inheritance_from_non_parameter(self):

FILE: test/cmdline_test.py
  class SomeTask (line 31) | class SomeTask(luigi.Task):
    method output (line 34) | def output(self):
    method run (line 37) | def run(self):
  class AmbiguousClass (line 43) | class AmbiguousClass(luigi.Task):
  class AmbiguousClass (line 47) | class AmbiguousClass(luigi.Task):  # NOQA
  class TaskWithSameName (line 51) | class TaskWithSameName(luigi.Task):
    method run (line 52) | def run(self):
    method run (line 59) | def run(self):
  class TaskWithSameName (line 56) | class TaskWithSameName(luigi.Task):  # NOQA
    method run (line 52) | def run(self):
    method run (line 59) | def run(self):
  class WriteToFile (line 63) | class WriteToFile(luigi.Task):
    method output (line 66) | def output(self):
    method run (line 69) | def run(self):
  class FooBaseClass (line 75) | class FooBaseClass(luigi.Task):
  class FooSubClass (line 79) | class FooSubClass(FooBaseClass):
  class ATaskThatFails (line 83) | class ATaskThatFails(luigi.Task):
    method run (line 84) | def run(self):
  class RequiredConfig (line 88) | class RequiredConfig(luigi.Config):
  class TaskThatRequiresConfig (line 92) | class TaskThatRequiresConfig(luigi.WrapperTask):
    method requires (line 93) | def requires(self):
  class SubTaskThatFails (line 98) | class SubTaskThatFails(luigi.Task):
    method complete (line 99) | def complete(self):
    method run (line 102) | def run(self):
  class CmdlineTest (line 106) | class CmdlineTest(unittest.TestCase):
    method setUp (line 107) | def setUp(self):
    method tearDown (line 111) | def tearDown(self):
    method _clean_config (line 116) | def _clean_config(self):
    method _restore_config (line 120) | def _restore_config(self):
    method test_cmdline_main_task_cls (line 124) | def test_cmdline_main_task_cls(self, logger):
    method test_cmdline_local_scheduler (line 129) | def test_cmdline_local_scheduler(self, logger):
    method test_cmdline_other_task (line 134) | def test_cmdline_other_task(self, logger):
    method test_cmdline_ambiguous_class (line 139) | def test_cmdline_ambiguous_class(self, logger):
    method test_setup_interface_logging (line 144) | def test_setup_interface_logging(self, handler, logger):
    method test_non_existent_class (line 167) | def test_non_existent_class(self, print_usage):
    method test_no_task (line 171) | def test_no_task(self, print_usage):
    method test_luigid_logging_conf (line 174) | def test_luigid_logging_conf(self):
    method test_luigid_no_logging_conf (line 181) | def test_luigid_no_logging_conf(self):
    method test_luigid_missing_logging_conf (line 194) | def test_luigid_missing_logging_conf(self):
  class InvokeOverCmdlineTest (line 208) | class InvokeOverCmdlineTest(unittest.TestCase):
    method _run_cmdline (line 209) | def _run_cmdline(self, args):
    method test_bin_luigi (line 217) | def test_bin_luigi(self):
    method test_direct_python (line 223) | def test_direct_python(self):
    method test_python_module (line 229) | def test_python_module(self):
    method test_direct_python_help (line 235) | def test_direct_python_help(self):
    method test_direct_python_help_class (line 240) | def test_direct_python_help_class(self):
    method test_bin_luigi_help (line 245) | def test_bin_luigi_help(self):
    method test_python_module_luigi_help (line 250) | def test_python_module_luigi_help(self):
    method test_bin_luigi_help_no_module (line 255) | def test_bin_luigi_help_no_module(self):
    method test_bin_luigi_help_not_spammy (line 259) | def test_bin_luigi_help_not_spammy(self):
    method test_bin_luigi_all_help_spammy (line 266) | def test_bin_luigi_all_help_spammy(self):
    method test_error_mesage_on_misspelled_task (line 276) | def test_error_mesage_on_misspelled_task(self):
    method test_bin_luigi_no_parameters (line 280) | def test_bin_luigi_no_parameters(self):
    method test_python_module_luigi_no_parameters (line 284) | def test_python_module_luigi_no_parameters(self):
    method test_bin_luigi_help_class (line 288) | def test_bin_luigi_help_class(self):
    method test_python_module_help_class (line 293) | def test_python_module_help_class(self):
    method test_bin_luigi_options_before_task (line 298) | def test_bin_luigi_options_before_task(self):
    method test_bin_fail_on_unrecognized_args (line 303) | def test_bin_fail_on_unrecognized_args(self):
    method test_deps_py_script (line 307) | def test_deps_py_script(self):
    method test_deps_tree_py_script (line 317) | def test_deps_tree_py_script(self):
    method test_bin_mentions_misspelled_task (line 327) | def test_bin_mentions_misspelled_task(self):
    method test_stack_trace_has_no_inner (line 338) | def test_stack_trace_has_no_inner(self):
    method test_cmd_line_params_are_available_for_execution_summary (line 352) | def test_cmd_line_params_are_available_for_execution_summary(self):

FILE: test/config_env_test.py
  class ConfigParserTest (line 25) | class ConfigParserTest(LuigiTestCase):
    method setUp (line 30) | def setUp(self):
    method tearDown (line 37) | def tearDown(self):
    method test_basic_interpolation (line 54) | def test_basic_interpolation(self):
    method test_env_interpolation (line 71) | def test_env_interpolation(self):
    method test_underscore_vs_dash_style (line 93) | def test_underscore_vs_dash_style(self):
    method test_underscore_vs_dash_style_priority (line 108) | def test_underscore_vs_dash_style_priority(self):
    method test_default_parser (line 113) | def test_default_parser(self):

FILE: test/config_toml_test.py
  class TomlConfigParserTest (line 22) | class TomlConfigParserTest(LuigiTestCase):
    method setUpClass (line 24) | def setUpClass(cls):
    method setUp (line 28) | def setUp(self):
    method test_get_config (line 32) | def test_get_config(self):
    method test_file_reading (line 36) | def test_file_reading(self):
    method test_get (line 40) | def test_get(self):
    method test_set (line 57) | def test_set(self):
    method test_has_option (line 66) | def test_has_option(self):
  class HelpersTest (line 73) | class HelpersTest(LuigiTestCase):
    method test_add_without_install (line 74) | def test_add_without_install(self):
    method test_get_without_install (line 81) | def test_get_without_install(self):

FILE: test/conftest.py
  function reset_luigi_registry (line 9) | def reset_luigi_registry():
  function pytest_collection_modifyitems (line 25) | def pytest_collection_modifyitems(items: List[pytest.Item]) -> None:

FILE: test/contrib/_webhdfs_test.py
  class TestWebHdfsTarget (line 27) | class TestWebHdfsTarget(unittest.TestCase):
    method setUp (line 34) | def setUp(self):
    method tearDown (line 40) | def tearDown(self):
    method test_write (line 44) | def test_write(self):
    method test_read (line 52) | def test_read(self):
    method test_read_lines (line 59) | def test_read_lines(self):

FILE: test/contrib/azureblob_test.py
  class AzureBlobClientTest (line 40) | class AzureBlobClientTest(unittest.TestCase):
    method setUp (line 41) | def setUp(self):
    method tearDown (line 44) | def tearDown(self):
    method test_splitfilepath_blob_none (line 47) | def test_splitfilepath_blob_none(self):
    method test_splitfilepath_blob_toplevel (line 52) | def test_splitfilepath_blob_toplevel(self):
    method test_splitfilepath_blob_nested (line 57) | def test_splitfilepath_blob_nested(self):
    method test_create_delete_container (line 62) | def test_create_delete_container(self):
    method test_upload_copy_move_remove_blob (line 76) | def test_upload_copy_move_remove_blob(self):
  class MovieScriptTask (line 129) | class MovieScriptTask(luigi.Task):
    method output (line 130) | def output(self):
    method run (line 133) | def run(self):
  class AzureJsonDumpTask (line 143) | class AzureJsonDumpTask(luigi.Task):
    method output (line 144) | def output(self):
    method run (line 147) | def run(self):
  class FinalTask (line 152) | class FinalTask(luigi.Task):
    method requires (line 153) | def requires(self):
    method run (line 156) | def run(self):
    method output (line 166) | def output(self):
  class AzureBlobTargetTest (line 171) | class AzureBlobTargetTest(unittest.TestCase):
    method setUp (line 172) | def setUp(self):
    method tearDown (line 175) | def tearDown(self):
    method test_AzureBlobTarget (line 178) | def test_AzureBlobTarget(self):

FILE: test/contrib/batch_test.py
  class MockBotoBatchClient (line 31) | class MockBotoBatchClient:
    method describe_job_queues (line 32) | def describe_job_queues(self):
    method list_jobs (line 35) | def list_jobs(self, jobQueue="", jobStatus=""):
    method describe_jobs (line 38) | def describe_jobs(self, jobs=[]):
    method submit_job (line 44) | def submit_job(self, jobDefinition="", jobName="", jobQueue="", parame...
    method register_job_definition (line 47) | def register_job_definition(self, **kwargs):
  class MockBotoLogsClient (line 51) | class MockBotoLogsClient:
    method get_log_events (line 52) | def get_log_events(self, logGroupName="", logStreamName="", startFromH...
  class BatchClientTest (line 58) | class BatchClientTest(unittest.TestCase):
    method setUp (line 59) | def setUp(self):
    method test_get_active_queue (line 64) | def test_get_active_queue(self):
    method test_get_job_id_from_name (line 67) | def test_get_job_id_from_name(self):
    method test_get_job_status (line 70) | def test_get_job_status(self):
    method test_get_logs (line 73) | def test_get_logs(self):
    method test_submit_job (line 77) | def test_submit_job(self):
    method test_submit_job_specific_queue (line 81) | def test_submit_job_specific_queue(self):
    method test_submit_job_non_existant_queue (line 85) | def test_submit_job_non_existant_queue(self):
    method test_wait_on_job (line 89) | def test_wait_on_job(self):
    method test_wait_on_job_failed (line 93) | def test_wait_on_job_failed(self):
  class BatchTaskTest (line 103) | class BatchTaskTest(unittest.TestCase):
    method setUp (line 104) | def setUp(self):

FILE: test/contrib/beam_dataflow_test.py
  class TestDataflowParamKeys (line 30) | class TestDataflowParamKeys(beam_dataflow.DataflowParamKeys):
  class TestRequires (line 51) | class TestRequires(luigi.ExternalTask):
    method output (line 52) | def output(self):
  class SimpleTestTask (line 56) | class SimpleTestTask(beam_dataflow.BeamDataflowJobTask):
    method requires (line 59) | def requires(self):
    method output (line 62) | def output(self):
    method dataflow_executable (line 65) | def dataflow_executable(self):
  class FullTestTask (line 69) | class FullTestTask(beam_dataflow.BeamDataflowJobTask):
    method requires (line 91) | def requires(self):
    method output (line 94) | def output(self):
    method args (line 97) | def args(self):
    method dataflow_executable (line 100) | def dataflow_executable(self):
  class FilePatternsTestTask (line 104) | class FilePatternsTestTask(beam_dataflow.BeamDataflowJobTask):
    method requires (line 107) | def requires(self):
    method file_pattern (line 110) | def file_pattern(self):
    method output (line 113) | def output(self):
    method dataflow_executable (line 116) | def dataflow_executable(self):
  class DummyCmdLineTestTask (line 120) | class DummyCmdLineTestTask(beam_dataflow.BeamDataflowJobTask):
    method dataflow_executable (line 123) | def dataflow_executable(self):
    method requires (line 126) | def requires(self):
    method output (line 129) | def output(self):
    method _mk_cmd_line (line 132) | def _mk_cmd_line(self):
  class BeamDataflowTest (line 137) | class BeamDataflowTest(unittest.TestCase):
    method test_dataflow_simple_cmd_line_args (line 138) | def test_dataflow_simple_cmd_line_args(self):
    method test_dataflow_full_cmd_line_args (line 146) | def test_dataflow_full_cmd_line_args(self):
    method test_dataflow_with_file_patterns (line 179) | def test_dataflow_with_file_patterns(self):
    method test_dataflow_with_invalid_file_patterns (line 185) | def test_dataflow_with_invalid_file_patterns(self):
    method test_dataflow_input_arg_formatting (line 191) | def test_dataflow_input_arg_formatting(self):
    method test_task_output_arg_completion (line 236) | def test_task_output_arg_completion(self):
    method test_get_target_path (line 263) | def test_get_target_path(self):
    method test_dataflow_runner_resolution (line 273) | def test_dataflow_runner_resolution(self):
    method test_dataflow_successful_run_callbacks (line 285) | def test_dataflow_successful_run_callbacks(self):
    method test_dataflow_successful_run_invalid_output_callbacks (line 302) | def test_dataflow_successful_run_invalid_output_callbacks(self):
    method test_dataflow_failed_run_callbacks (line 322) | def test_dataflow_failed_run_callbacks(self, popen, os_exit):

FILE: test/contrib/bigquery_avro_test.py
  class BigQueryAvroTest (line 32) | class BigQueryAvroTest(unittest.TestCase):
    method test_writer_schema_method_existence (line 33) | def test_writer_schema_method_existence(self):

FILE: test/contrib/bigquery_gcloud_test.py
  function bucket_url (line 59) | def bucket_url(suffix):
  class TestLoadTask (line 67) | class TestLoadTask(bigquery.BigQueryLoadTask):
    method schema (line 74) | def schema(self):
    method source_uris (line 80) | def source_uris(self):
    method output (line 83) | def output(self):
  class TestRunQueryTask (line 88) | class TestRunQueryTask(bigquery.BigQueryRunQueryTask):
    method output (line 93) | def output(self):
  class TestExtractTask (line 98) | class TestExtractTask(bigquery.BigQueryExtractTask):
    method output (line 109) | def output(self):
    method requires (line 112) | def requires(self):
  class BigQueryGcloudTest (line 117) | class BigQueryGcloudTest(unittest.TestCase):
    method setUp (line 118) | def setUp(self):
    method test_extract_to_gcs_csv (line 150) | def test_extract_to_gcs_csv(self):
    method test_extract_to_gcs_csv_alternate (line 165) | def test_extract_to_gcs_csv_alternate(self):
    method test_extract_to_gcs_json (line 182) | def test_extract_to_gcs_json(self):
    method test_extract_to_gcs_avro (line 197) | def test_extract_to_gcs_avro(self):
    method test_load_eu_to_undefined (line 212) | def test_load_eu_to_undefined(self):
    method test_load_us_to_eu (line 216) | def test_load_us_to_eu(self):
    method test_load_eu_to_eu (line 220) | def test_load_e

[
  {
    "path": ".coveragerc",
    "chars": 284,
    "preview": "[report]\nomit =\n    luigi/mrrunner.py\n    test/_test_time_generated_module*.py\n    */python?.?/*\n    */site-packages/nos"
  },
  {
    "path": ".github/CODEOWNERS",
    "chars": 434,
    "preview": "# The following patterns are used to auto-assign review requests\n# to specific individuals. Order is important; the last"
  },
  {
    "path": ".github/ISSUE_TEMPLATE.md",
    "chars": 811,
    "preview": "<!---\nWe use GitHub issues mainly for tracking bugs and feature requests.\nQuestions for how to use luigi can be sent to "
  },
  {
    "path": ".github/PULL_REQUEST_TEMPLATE.md",
    "chars": 685,
    "preview": "<!--- This template is optional. Please use it as a starting point to help guide PRs -->\n\n<!--- Provide a general summar"
  },
  {
    "path": ".github/stale.yml",
    "chars": 800,
    "preview": "# Number of days of inactivity before an issue becomes stale\ndaysUntilStale: 120\n# Number of days of inactivity before a"
  },
  {
    "path": ".github/workflows/codeql.yml",
    "chars": 2518,
    "preview": "name: \"CodeQL\"\n\non:\n  push:\n    branches: [ 'master' ]\n  pull_request:\n    # The branches below must be a subset of the "
  },
  {
    "path": ".github/workflows/pythonbuild.yml",
    "chars": 6252,
    "preview": "name: Build\n\non:\n  push:\n    branches:\n      - master\n  pull_request:\n\njobs:\n  core:\n    runs-on: ubuntu-22.04\n\n    stra"
  },
  {
    "path": ".gitignore",
    "chars": 2347,
    "preview": ".coverage.*\ndoc/api/*.rst\ntest/gcloud-credentials.json\n.hypothesis/\n\n.nicesetup\n\nclient.cfg\nluigi.cfg\n\nhadoop_test.py\nmi"
  },
  {
    "path": ".readthedocs.yaml",
    "chars": 435,
    "preview": "version: 2\n\nbuild:\n  os: ubuntu-24.04\n  tools:\n    python: \"3.13\"\n  jobs:\n    pre_create_environment:\n      - asdf plugi"
  },
  {
    "path": "CONTRIBUTING.rst",
    "chars": 2280,
    "preview": "Code of conduct\n---------------\n\nThis project adheres to the `Open Code of Conduct \n<https://github.com/spotify/code-of-"
  },
  {
    "path": "LICENSE",
    "chars": 11345,
    "preview": "                                 Apache License\n                           Version 2.0, January 2004\n                   "
  },
  {
    "path": "README.rst",
    "chars": 12986,
    "preview": ".. figure:: https://raw.githubusercontent.com/spotify/luigi/master/doc/luigi.png\n   :alt: Luigi Logo\n   :align: center\n\n"
  },
  {
    "path": "RELEASE-PROCESS.rst",
    "chars": 1147,
    "preview": "For maintainers of Luigi, who have push access to pypi. Here's how you upload\nLuigi to pypi.\n\n#. Make sure [uv](https://"
  },
  {
    "path": "SECURITY.md",
    "chars": 265,
    "preview": "# Security Policy\n\n## Reporting a Vulnerability\n\nPlease report sensitive security issues via Spotify's [bug-bounty progr"
  },
  {
    "path": "bin/luigi",
    "chars": 264,
    "preview": "#!/usr/bin/env python\n\nimport sys\nimport warnings\nimport luigi.cmdline\n\n\ndef main(argv):\n    warnings.warn(\"'bin/luigi' "
  },
  {
    "path": "bin/luigid",
    "chars": 263,
    "preview": "#!/usr/bin/env python\n\nimport sys\nimport warnings\nimport luigi.cmdline\n\n\ndef main(argv):\n    warnings.warn(\"'bin/luigid'"
  },
  {
    "path": "catalog-info.yaml",
    "chars": 112,
    "preview": "apiVersion: backstage.io/v1alpha1\nkind: Component\nmetadata:\n  name: luigi\nspec:\n  type: library\n  owner: dataex\n"
  },
  {
    "path": "codecov.yml",
    "chars": 1130,
    "preview": "codecov:\n  require_ci_to_pass: true\n  notify:\n    wait_for_ci: true\n\ncoverage:\n  precision: 2\n  round: down\n  range: \"50"
  },
  {
    "path": "doc/.gitignore",
    "chars": 26,
    "preview": "_static\n_build\n_templates\n"
  },
  {
    "path": "doc/Makefile",
    "chars": 6758,
    "preview": "# Makefile for Sphinx documentation\n#\n\n# You can set these variables from the command line.\nSPHINXOPTS    =\nSPHINXBUILD "
  },
  {
    "path": "doc/central_scheduler.rst",
    "chars": 4141,
    "preview": "Using the Central Scheduler\n---------------------------\n\nWhile the ``--local-scheduler`` flag is useful for development "
  },
  {
    "path": "doc/conf.py",
    "chars": 10317,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Luigi documentation build configuration file, created by\n# sphinx-quickstart on Sat Feb  8 0"
  },
  {
    "path": "doc/configuration.rst",
    "chars": 34930,
    "preview": "Configuration\n=============\n\nAll configuration can be done by adding configuration files.\n\nSupported config parsers:\n\n* "
  },
  {
    "path": "doc/design_and_limitations.rst",
    "chars": 2230,
    "preview": "Design and limitations\n----------------------\n\nLuigi is the successor to a couple of attempts that we weren't fully happ"
  },
  {
    "path": "doc/example_top_artists.rst",
    "chars": 11014,
    "preview": "Example – Top Artists\n---------------------\n\nThis is a very simplified case of something we do at Spotify a lot.\nAll use"
  },
  {
    "path": "doc/execution_model.rst",
    "chars": 4282,
    "preview": "Execution Model\n---------------\n\nLuigi has a quite simple model for execution and triggering.\n\nWorkers and task executio"
  },
  {
    "path": "doc/index.rst",
    "chars": 737,
    "preview": ".. Luigi documentation master file, created by\n   sphinx-quickstart on Sat Feb  8 00:56:43 2014.\n   You can adapt this f"
  },
  {
    "path": "doc/logging.rst",
    "chars": 1626,
    "preview": "Configure logging\n-----------------\n\n\nConfig options:\n~~~~~~~~~~~~~~~\n\nSome config options for config [core] section\n\nlo"
  },
  {
    "path": "doc/luigi_patterns.rst",
    "chars": 18117,
    "preview": "Luigi Patterns\n--------------\n\nCode Reuse\n~~~~~~~~~~\n\nOne nice thing about Luigi is that it's super easy to depend on ta"
  },
  {
    "path": "doc/mypy.rst",
    "chars": 784,
    "preview": "Mypy plugin\n--------------\n\nMypy plugin provides type checking for ``luigi.Task`` using Mypy.\n\nRequire Python 3.8 or lat"
  },
  {
    "path": "doc/parameters.rst",
    "chars": 5536,
    "preview": "Parameters\n----------\n\nParameters is the Luigi equivalent of creating a constructor for each Task.\nLuigi requires you to"
  },
  {
    "path": "doc/running_luigi.rst",
    "chars": 4627,
    "preview": "Running Luigi\n-------------\n\nRunning from the Command Line\n^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n\nThe preferred way to run Luigi"
  },
  {
    "path": "doc/tasks.rst",
    "chars": 12900,
    "preview": "Tasks\n-----\n\nTasks are where the execution takes place.\nTasks depend on each other and output targets.\n\nAn outline of ho"
  },
  {
    "path": "doc/workflows.rst",
    "chars": 3892,
    "preview": "Building workflows\n------------------\n\nThere are two fundamental building blocks of Luigi -\nthe :class:`~luigi.task.Task"
  },
  {
    "path": "examples/__init__.py",
    "chars": 603,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/config.toml",
    "chars": 920,
    "preview": "\n[hdfs]\nclient = \"hadoopcli\"\nnamenode_host = \"localhost\"\nnamenode_port = 50030\n\n# LOGGING\n\n[logging]\nversion = 1\ndisable"
  },
  {
    "path": "examples/dynamic_requirements.py",
    "chars": 3733,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/elasticsearch_index.py",
    "chars": 3370,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/execution_summary_example.py",
    "chars": 3319,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2015-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/foo.py",
    "chars": 1463,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/foo_complex.py",
    "chars": 1877,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/ftp_experiment_outputs.py",
    "chars": 3239,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/hello_world.py",
    "chars": 501,
    "preview": "\"\"\"\nYou can run this example like this:\n\n    .. code:: console\n\n            $ luigi --module examples.hello_world exampl"
  },
  {
    "path": "examples/kubernetes.py",
    "chars": 1924,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2015 Outlier Bio, LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "examples/per_task_retry_policy.py",
    "chars": 5236,
    "preview": "# -*- coding: utf-8 -*-\n\n\"\"\"\nYou can run this example like this:\n\n    .. code:: console\n\n            $ luigi --module ex"
  },
  {
    "path": "examples/pyspark_wc.py",
    "chars": 3360,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/spark_als.py",
    "chars": 4363,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/ssh_remote_execution.py",
    "chars": 2721,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/terasort.py",
    "chars": 3267,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/top_artists.py",
    "chars": 8851,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/top_artists_spark.py",
    "chars": 623,
    "preview": "# -*- coding: utf-8 -*-\n\nimport operator\nimport sys\n\nfrom pyspark.sql import SparkSession\n\n\ndef main(argv):\n    input_pa"
  },
  {
    "path": "examples/wordcount.py",
    "chars": 2905,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "examples/wordcount_hadoop.py",
    "chars": 2728,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/__init__.py",
    "chars": 3993,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/__main__.py",
    "chars": 683,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2016 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/__version__.py",
    "chars": 35,
    "preview": "# coding: utf-8\n\nVERSION = \"3.8.0\"\n"
  },
  {
    "path": "luigi/batch_notifier.py",
    "chars": 8797,
    "preview": "\"\"\"\nLibrary for sending batch notifications from the Luigi scheduler. This module\nis internal to Luigi and not designed "
  },
  {
    "path": "luigi/cmdline.py",
    "chars": 1370,
    "preview": "import argparse\nimport sys\n\nfrom luigi.retcodes import run_with_retcodes\nfrom luigi.setup_logging import DaemonLogging\n\n"
  },
  {
    "path": "luigi/cmdline_parser.py",
    "chars": 5159,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\")"
  },
  {
    "path": "luigi/configuration/__init__.py",
    "chars": 836,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/configuration/base_parser.py",
    "chars": 1305,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/configuration/cfg_parser.py",
    "chars": 8274,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/configuration/core.py",
    "chars": 2641,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/configuration/toml_parser.py",
    "chars": 2917,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2018 Vote Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");"
  },
  {
    "path": "luigi/contrib/__init__.py",
    "chars": 661,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/azureblob.py",
    "chars": 13928,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright (c) 2018 Microsoft Corporation\n#\n# Licensed under the Apache License, Version 2.0 "
  },
  {
    "path": "luigi/contrib/batch.py",
    "chars": 7790,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2018 Outlier Bio, LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "luigi/contrib/beam_dataflow.py",
    "chars": 16331,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2019 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\")"
  },
  {
    "path": "luigi/contrib/bigquery.py",
    "chars": 29480,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2015 Twitter Inc\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
  },
  {
    "path": "luigi/contrib/bigquery_avro.py",
    "chars": 4227,
    "preview": "\"\"\"Specialized tasks for handling Avro data in BigQuery from GCS.\"\"\"\n\nimport logging\n\nfrom luigi.contrib.bigquery import"
  },
  {
    "path": "luigi/contrib/datadog_metric.py",
    "chars": 5430,
    "preview": "import logging\n\nfrom luigi import parameter\nfrom luigi.metrics import MetricsCollector\nfrom luigi.task import Config\n\nlo"
  },
  {
    "path": "luigi/contrib/dataproc.py",
    "chars": 9976,
    "preview": "\"\"\"luigi bindings for Google Dataproc on Google Cloud\"\"\"\n\nimport logging\nimport os\nimport time\n\nimport luigi\nfrom luigi."
  },
  {
    "path": "luigi/contrib/docker_runner.py",
    "chars": 8902,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2017 Open Targets\n#\n# Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "luigi/contrib/dropbox.py",
    "chars": 11570,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright (c) 2019 Jose-Ignacio Riaño Chico\n#\n# Licensed under the Apache License, Version 2"
  },
  {
    "path": "luigi/contrib/ecs.py",
    "chars": 9535,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2015 Outlier Bio, LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "luigi/contrib/esindex.py",
    "chars": 13672,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/external_daily_snapshot.py",
    "chars": 2380,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2017 Spotify AB.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
  },
  {
    "path": "luigi/contrib/external_program.py",
    "chars": 11159,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2016 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/ftp.py",
    "chars": 13140,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/gcp.py",
    "chars": 1410,
    "preview": "\"\"\"\nCommon code for GCP (google cloud services) integration\n\"\"\"\n\nimport logging\n\nlogger = logging.getLogger(\"luigi-inter"
  },
  {
    "path": "luigi/contrib/gcs.py",
    "chars": 18052,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2015 Twitter Inc\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
  },
  {
    "path": "luigi/contrib/hadoop.py",
    "chars": 37054,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/hadoop_jar.py",
    "chars": 5415,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/hdfs/__init__.py",
    "chars": 2900,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/hdfs/abstract_client.py",
    "chars": 2824,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/hdfs/clients.py",
    "chars": 1924,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/hdfs/config.py",
    "chars": 4005,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/hdfs/error.py",
    "chars": 1029,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/hdfs/format.py",
    "chars": 5975,
    "preview": "import logging\nimport os\n\nimport luigi.format\nfrom luigi.contrib.hdfs import config as hdfs_config\nfrom luigi.contrib.hd"
  },
  {
    "path": "luigi/contrib/hdfs/hadoopcli_clients.py",
    "chars": 9424,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/hdfs/target.py",
    "chars": 7196,
    "preview": "#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use"
  },
  {
    "path": "luigi/contrib/hdfs/webhdfs_client.py",
    "chars": 6482,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2015 VNG Corporation\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/hive.py",
    "chars": 19129,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/kubernetes.py",
    "chars": 13674,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2015 Outlier Bio, LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "luigi/contrib/lsf.py",
    "chars": 11980,
    "preview": "# -*- coding: utf-8 -*-\n\n\"\"\"\n.. Copyright 2012-2015 Spotify AB\n   Copyright 2018\n   Copyright 2018 EMBL-European Bioinfo"
  },
  {
    "path": "luigi/contrib/lsf_runner.py",
    "chars": 2301,
    "preview": "# -*- coding: utf-8 -*-\n\n\"\"\"\n.. Copyright 2012-2015 Spotify AB\n   Copyright 2018\n   Copyright 2018 EMBL-European Bioinfo"
  },
  {
    "path": "luigi/contrib/mongodb.py",
    "chars": 6400,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2017 Big Datext Inc\n#\n# Licensed under the Apache License, Version 2.0 (the \"Licen"
  },
  {
    "path": "luigi/contrib/mssqldb.py",
    "chars": 5295,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/mysqldb.py",
    "chars": 8325,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/opener.py",
    "chars": 7047,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/pai.py",
    "chars": 10923,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2017 Open Targets\n#\n# Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "luigi/contrib/pig.py",
    "chars": 6517,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/postgres.py",
    "chars": 15874,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/presto.py",
    "chars": 7620,
    "preview": "import inspect\nimport logging\nimport re\nfrom collections import OrderedDict\nfrom contextlib import closing\nfrom enum imp"
  },
  {
    "path": "luigi/contrib/prometheus_metric.py",
    "chars": 3039,
    "preview": "from prometheus_client import CONTENT_TYPE_LATEST, CollectorRegistry, Counter, Gauge, generate_latest\n\nfrom luigi import"
  },
  {
    "path": "luigi/contrib/pyspark_runner.py",
    "chars": 3841,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2020 Spotify AB\n#\n# Licensed under the Apache License, "
  },
  {
    "path": "luigi/contrib/rdbms.py",
    "chars": 11125,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/redis_store.py",
    "chars": 3014,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/redshift.py",
    "chars": 24400,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/s3.py",
    "chars": 27135,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/salesforce.py",
    "chars": 26833,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/scalding.py",
    "chars": 10409,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/sge.py",
    "chars": 13385,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/sge_runner.py",
    "chars": 2833,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/simulate.py",
    "chars": 3407,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/spark.py",
    "chars": 12273,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/sparkey.py",
    "chars": 1970,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/sqla.py",
    "chars": 16184,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright (c) 2015 Gouthaman Balaraman\n#\n# Licensed under the Apache License, Version 2.0 (t"
  },
  {
    "path": "luigi/contrib/ssh.py",
    "chars": 12242,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/target.py",
    "chars": 2812,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/contrib/webhdfs.py",
    "chars": 2921,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/date_interval.py",
    "chars": 8608,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/db_task_history.py",
    "chars": 11397,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/event.py",
    "chars": 1757,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/execution_summary.py",
    "chars": 20201,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2015-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/format.py",
    "chars": 14427,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/freezing.py",
    "chars": 2138,
    "preview": "\"\"\"Internal-only module with immutable data structures.\n\nPlease, do not use it outside of Luigi codebase itself.\n\"\"\"\n\nfr"
  },
  {
    "path": "luigi/interface.py",
    "chars": 8540,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/local_target.py",
    "chars": 6185,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/lock.py",
    "chars": 5366,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/metrics.py",
    "chars": 2582,
    "preview": "import abc\nimport importlib\nfrom enum import Enum\n\n\nclass MetricsCollectors(Enum):\n    custom = -1\n    default = 1\n    n"
  },
  {
    "path": "luigi/mock.py",
    "chars": 5679,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/mypy.py",
    "chars": 20313,
    "preview": "\"\"\"Plugin that provides support for luigi.Task\n\nThis Code reuses the code from mypy.plugins.dataclasses\nhttps://github.c"
  },
  {
    "path": "luigi/notifications.py",
    "chars": 13833,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/parameter.py",
    "chars": 61330,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/process.py",
    "chars": 3446,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/py.typed",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "luigi/retcodes.py",
    "chars": 4347,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2015-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/rpc.py",
    "chars": 6736,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/safe_extractor.py",
    "chars": 3567,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/scheduler.py",
    "chars": 65815,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/server.py",
    "chars": 14515,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/setup_logging.py",
    "chars": 5734,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2018 Vote Inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");"
  },
  {
    "path": "luigi/static/visualiser/css/luigi.css",
    "chars": 3413,
    "preview": ".nodeCircle {\n  stroke: #fff;\n  stroke-width: 1.5px;\n}\ntext {\n    font-size:8pt;\n}\n\n.link {\n  stroke: #999;\n  stroke-opa"
  },
  {
    "path": "luigi/static/visualiser/css/tipsy.css",
    "chars": 2162,
    "preview": ".tipsy { font-size: 10px; position: absolute; padding: 5px; z-index: 100000; }\n  .tipsy-inner { background-color: #000; "
  },
  {
    "path": "luigi/static/visualiser/index.html",
    "chars": 33256,
    "preview": "<!DOCTYPE html>\n<html lang=\"en\">\n    <head>\n        <title>Luigi Task Visualiser</title>\n        <link href=\"css/luigi.c"
  },
  {
    "path": "luigi/static/visualiser/js/graph.js",
    "chars": 12101,
    "preview": "Graph = (function() {\n    var statusColors = {\n        \"FAILED\":\"#DD0000\",\n        \"RUNNING\":\"#0044DD\",\n        \"BATCH_R"
  },
  {
    "path": "luigi/static/visualiser/js/luigi.js",
    "chars": 8076,
    "preview": "var LuigiAPI = (function() {\n    function LuigiAPI (urlRoot) {\n        this.urlRoot = urlRoot;\n    }\n\n    function flatt"
  },
  {
    "path": "luigi/static/visualiser/js/test/graph_test.js",
    "chars": 3969,
    "preview": "module(\"graph.js\");\n\ntest(\"nodeFromTask\", function() {\n    var task = {\n        deps: [\"B1\",\"C1\"],\n        taskId: \"A1\","
  },
  {
    "path": "luigi/static/visualiser/js/tipsy.js",
    "chars": 11097,
    "preview": "// tipsy, facebook style tooltips for jquery\n// version 1.0.0a\n// (c) 2008-2010 jason frame [jason@onehackoranother.com]"
  },
  {
    "path": "luigi/static/visualiser/js/util.js",
    "chars": 189,
    "preview": "function escapeHtml(unsafe) {\n  return unsafe\n    .replace(/&/g, \"&amp;\")\n    .replace(/</g, \"&lt;\")\n    .replace(/>/g, "
  },
  {
    "path": "luigi/static/visualiser/js/visualiserApp.js",
    "chars": 58572,
    "preview": "function visualiserApp(luigi) {\n    var templates = {};\n    var typingTimer = 0;\n    var dt; // DataTable instantiated i"
  },
  {
    "path": "luigi/static/visualiser/lib/URI/1.18.2/URI.js",
    "chars": 62764,
    "preview": "/*!\n * URI.js - Mutating URLs\n *\n * Version: 1.18.2\n *\n * Author: Rodney Rehm\n * Web: http://medialize.github.io/URI.js/"
  },
  {
    "path": "luigi/static/visualiser/lib/mustache.js",
    "chars": 14853,
    "preview": "/*!\n * mustache.js - Logic-less {{mustache}} templates with JavaScript\n * http://github.com/janl/mustache.js\n */\n\n/*glob"
  },
  {
    "path": "luigi/static/visualiser/mockdata/dep_graph",
    "chars": 1097,
    "preview": "{\n    \"response\": {\n        \"FactorTask(product=12)\": {\n            \"deps\": [\n                \"FactorTask(product=2)\",\n "
  },
  {
    "path": "luigi/static/visualiser/mockdata/fetch_error",
    "chars": 400,
    "preview": "{\n    \"response\": {\n        \"taskId\": \"FactorTask(product=2)\",\n        \"error\": \"Runtime error:\\nTraceback (most recent "
  },
  {
    "path": "luigi/static/visualiser/mockdata/task_list",
    "chars": 1097,
    "preview": "{\n    \"response\": {\n        \"FactorTask(product=12)\": {\n            \"deps\": [\n                \"FactorTask(product=2)\",\n "
  },
  {
    "path": "luigi/static/visualiser/test.html",
    "chars": 510,
    "preview": "<!DOCTYPE html>\n<html>\n    <head>\n        <title>Luigi Visualiser Tests</title>\n        <link rel=\"stylesheet\" href=\"htt"
  },
  {
    "path": "luigi/target.py",
    "chars": 12155,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/task.py",
    "chars": 36318,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/task_history.py",
    "chars": 1989,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/task_register.py",
    "chars": 8071,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/task_status.py",
    "chars": 892,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/templates/history.html",
    "chars": 4270,
    "preview": "<!--\n@Copyright 2015 Naver Corp.\n@Author Yeseul Park (yeseul.park@navercorp.com)\n-->\n\n<!-- Extend our site layout -->\n{%"
  },
  {
    "path": "luigi/templates/layout.html",
    "chars": 3033,
    "preview": "<!--\n@Copyright 2015 Naver Corp.\n@Author Yeseul Park (yeseul.park@navercorp.com)\n-->\n\n<!DOCTYPE html>\n<html lang=\"en\">\n "
  },
  {
    "path": "luigi/templates/menu.html",
    "chars": 553,
    "preview": "<!--\n@Copyright 2015 Naver Corp.\n@Author Yeseul Park (yeseul.park@navercorp.com)\n-->\n\n<!-- Extend our site layout -->\n{%"
  },
  {
    "path": "luigi/templates/recent.html",
    "chars": 730,
    "preview": "{% extends \"layout.html\" %}\n{% block content %}\n<h2>Luigi Task History</h2>\n<table class=\"table table-striped table-bord"
  },
  {
    "path": "luigi/templates/show.html",
    "chars": 1282,
    "preview": "{% extends \"layout.html\" %}\n{% block content %}\n<div class=\"row\">\n  <div class=\"span6\">\n    <h3>Info</h3>\n    <table cla"
  },
  {
    "path": "luigi/tools/__init__.py",
    "chars": 751,
    "preview": "# -*- coding: utf-8 -*-\n# Copyright (c) 2014 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "luigi/tools/deps.py",
    "chars": 4689,
    "preview": "#!/usr/bin/env python\n\n\n# Finds all tasks and task outputs on the dependency paths from the given downstream task T\n# up"
  },
  {
    "path": "luigi/tools/deps_tree.py",
    "chars": 2532,
    "preview": "# -*- coding: utf-8 -*-\n\"\"\"\nThis module parses commands exactly the same as the luigi task runner. You must specify the "
  },
  {
    "path": "luigi/tools/luigi_grep.py",
    "chars": 2779,
    "preview": "#!/usr/bin/env python\n\nimport argparse\nimport json\nfrom collections import defaultdict\nfrom urllib.request import urlope"
  },
  {
    "path": "luigi/tools/range.py",
    "chars": 33506,
    "preview": "# -*- coding: utf-8 -*-\n# Copyright (c) 2014 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"License"
  },
  {
    "path": "luigi/util.py",
    "chars": 16371,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "luigi/worker.py",
    "chars": 51163,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "pyproject.toml",
    "chars": 5090,
    "preview": "[build-system]\nrequires = ['hatchling', 'hatch-fancy-pypi-readme']\nbuild-backend = 'hatchling.build'\n\n[project]\nname = \""
  },
  {
    "path": "scripts/ci/conditional_tox.sh",
    "chars": 167,
    "preview": "#!/usr/bin/env bash\n\nset -ex\n\nENDENV=$(echo $TOXENV | tail -c 7)\nif [[ $ENDENV == gcloud ]]\nthen\n  [[ $DIDNT_CREATE_GCP_"
  },
  {
    "path": "scripts/ci/install_start_azurite.sh",
    "chars": 385,
    "preview": "#!/usr/bin/env bash\n\necho \"$DOCKERHUB_TOKEN\" | docker login -u spotifyci --password-stdin\n\ndocker pull mcr.microsoft.com"
  },
  {
    "path": "scripts/ci/setup_hadoop_env.sh",
    "chars": 2460,
    "preview": "#!/usr/bin/env bash\n\nHADOOP_DISTRO=${HADOOP_DISTRO:-\"hdp\"}\n\nONLY_DOWNLOAD=${ONLY_DOWNLOAD:-false}\nONLY_EXTRACT=${ONLY_EX"
  },
  {
    "path": "scripts/ci/stop_azurite.sh",
    "chars": 107,
    "preview": "#!/usr/bin/env bash\ndocker stop \"$(docker ps -q --filter ancestor=mcr.microsoft.com/azure-storage/azurite)\""
  },
  {
    "path": "test/_mysqldb_test.py",
    "chars": 1546,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "test/_test_ftp.py",
    "chars": 7293,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "test/auto_namespace_test/__init__.py",
    "chars": 51,
    "preview": "import luigi\n\nluigi.auto_namespace(scope=__name__)\n"
  },
  {
    "path": "test/auto_namespace_test/my_namespace_test.py",
    "chars": 368,
    "preview": "from helpers import LuigiTestCase\n\nimport luigi\n\n\nclass MyNamespaceTest(LuigiTestCase):\n    def test_auto_namespace_scop"
  },
  {
    "path": "test/batch_notifier_test.py",
    "chars": 19923,
    "preview": "# coding=utf-8\nimport unittest\nfrom smtplib import SMTPServerDisconnected\n\nimport mock\n\nimport luigi.batch_notifier\n\nBAT"
  },
  {
    "path": "test/choice_parameter_test.py",
    "chars": 2252,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "test/clone_test.py",
    "chars": 2277,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "test/cmdline_test.py",
    "chars": 14445,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "test/config_env_test.py",
    "chars": 3725,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2018 Vote inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");"
  },
  {
    "path": "test/config_toml_test.py",
    "chars": 3011,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2018 Vote inc.\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\");"
  },
  {
    "path": "test/conftest.py",
    "chars": 1339,
    "preview": "from typing import List\n\nimport pytest\n\nimport luigi.task_register\n\n\n@pytest.fixture(autouse=True)\ndef reset_luigi_regis"
  },
  {
    "path": "test/contrib/__init__.py",
    "chars": 0,
    "preview": ""
  },
  {
    "path": "test/contrib/_webhdfs_test.py",
    "chars": 2104,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  },
  {
    "path": "test/contrib/azureblob_test.py",
    "chars": 6413,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2018 Microsoft Corporation\n#\n# Licensed under the Apache License, Version 2.0 (the"
  },
  {
    "path": "test/contrib/batch_test.py",
    "chars": 4124,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2018 Outlier Bio, LLC\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lic"
  },
  {
    "path": "test/contrib/beam_dataflow_test.py",
    "chars": 12065,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2019 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\")"
  },
  {
    "path": "test/contrib/bigquery_avro_test.py",
    "chars": 1617,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2019 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\")"
  },
  {
    "path": "test/contrib/bigquery_gcloud_test.py",
    "chars": 20810,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2015 Twitter Inc\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\""
  },
  {
    "path": "test/contrib/bigquery_test.py",
    "chars": 6164,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2019 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"License\")"
  },
  {
    "path": "test/contrib/cascading_test.py",
    "chars": 2770,
    "preview": "# -*- coding: utf-8 -*-\n#\n# Copyright 2012-2015 Spotify AB\n#\n# Licensed under the Apache License, Version 2.0 (the \"Lice"
  }
]

// ... and 129 more files (download for full content)