From 5050045e55429575cd6e408107040b94168e4ebc Mon Sep 17 00:00:00 2001 From: Manu Chevalier Date: Wed, 7 Aug 2024 16:43:32 +0200 Subject: [PATCH] Adding airflow with a specific DAG to update sensor data hourly --- .gitignore | 1 + airflow-webserver.pid | 1 + airflow.cfg | 2418 +++++++++++++++++++++++++++++++++ airflow.db | Bin 0 -> 1130496 bytes dags/sensors_and_more.py | 45 + standalone_admin_password.txt | 1 + webserver_config.py | 132 ++ 7 files changed, 2598 insertions(+) create mode 100644 airflow-webserver.pid create mode 100644 airflow.cfg create mode 100644 airflow.db create mode 100644 dags/sensors_and_more.py create mode 100644 standalone_admin_password.txt create mode 100644 webserver_config.py diff --git a/.gitignore b/.gitignore index ca4286f..5a2ec3e 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,4 @@ __pycache__ data *alias logs +data_bckp diff --git a/airflow-webserver.pid b/airflow-webserver.pid new file mode 100644 index 0000000..104bde2 --- /dev/null +++ b/airflow-webserver.pid @@ -0,0 +1 @@ +17243 diff --git a/airflow.cfg b/airflow.cfg new file mode 100644 index 0000000..2ce181d --- /dev/null +++ b/airflow.cfg @@ -0,0 +1,2418 @@ +[core] +# The folder where your airflow pipelines live, most likely a +# subfolder in a code repository. This path must be absolute. +# +# Variable: AIRFLOW__CORE__DAGS_FOLDER +# +dags_folder = /Users/palaeosaurus/Data-Projects/2024/sensors-and-more/dags + +# Hostname by providing a path to a callable, which will resolve the hostname. +# The format is "package.function". +# +# For example, default value ``airflow.utils.net.getfqdn`` means that result from patched +# version of `socket.getfqdn() `__, +# see related `CPython Issue `__. +# +# No argument should be required in the function specified. +# If using IP address as hostname is preferred, use value ``airflow.utils.net.get_host_ip_address`` +# +# Variable: AIRFLOW__CORE__HOSTNAME_CALLABLE +# +hostname_callable = airflow.utils.net.getfqdn + +# A callable to check if a python file has airflow dags defined or not and should +# return ``True`` if it has dags otherwise ``False``. +# If this is not provided, Airflow uses its own heuristic rules. +# +# The function should have the following signature +# +# .. code-block:: python +# +# def func_name(file_path: str, zip_file: zipfile.ZipFile | None = None) -> bool: ... +# +# Variable: AIRFLOW__CORE__MIGHT_CONTAIN_DAG_CALLABLE +# +might_contain_dag_callable = airflow.utils.file.might_contain_dag_via_default_heuristic + +# Default timezone in case supplied date times are naive +# can be `UTC` (default), `system`, or any `IANA ` +# timezone string (e.g. Europe/Amsterdam) +# +# Variable: AIRFLOW__CORE__DEFAULT_TIMEZONE +# +default_timezone = utc + +# The executor class that airflow should use. Choices include +# ``SequentialExecutor``, ``LocalExecutor``, ``CeleryExecutor``, +# ``KubernetesExecutor``, ``CeleryKubernetesExecutor``, ``LocalKubernetesExecutor`` or the +# full import path to the class when using a custom executor. +# +# Variable: AIRFLOW__CORE__EXECUTOR +# +executor = SequentialExecutor + +# The auth manager class that airflow should use. Full import path to the auth manager class. +# +# Variable: AIRFLOW__CORE__AUTH_MANAGER +# +auth_manager = airflow.providers.fab.auth_manager.fab_auth_manager.FabAuthManager + +# This defines the maximum number of task instances that can run concurrently per scheduler in +# Airflow, regardless of the worker count. Generally this value, multiplied by the number of +# schedulers in your cluster, is the maximum number of task instances with the running +# state in the metadata database. +# +# Variable: AIRFLOW__CORE__PARALLELISM +# +parallelism = 32 + +# The maximum number of task instances allowed to run concurrently in each DAG. To calculate +# the number of tasks that is running concurrently for a DAG, add up the number of running +# tasks for all DAG runs of the DAG. This is configurable at the DAG level with ``max_active_tasks``, +# which is defaulted as ``[core] max_active_tasks_per_dag``. +# +# An example scenario when this would be useful is when you want to stop a new dag with an early +# start date from stealing all the executor slots in a cluster. +# +# Variable: AIRFLOW__CORE__MAX_ACTIVE_TASKS_PER_DAG +# +max_active_tasks_per_dag = 16 + +# Are DAGs paused by default at creation +# +# Variable: AIRFLOW__CORE__DAGS_ARE_PAUSED_AT_CREATION +# +dags_are_paused_at_creation = True + +# The maximum number of active DAG runs per DAG. The scheduler will not create more DAG runs +# if it reaches the limit. This is configurable at the DAG level with ``max_active_runs``, +# which is defaulted as ``[core] max_active_runs_per_dag``. +# +# Variable: AIRFLOW__CORE__MAX_ACTIVE_RUNS_PER_DAG +# +max_active_runs_per_dag = 16 + +# (experimental) The maximum number of consecutive DAG failures before DAG is automatically paused. +# This is also configurable per DAG level with ``max_consecutive_failed_dag_runs``, +# which is defaulted as ``[core] max_consecutive_failed_dag_runs_per_dag``. +# If not specified, then the value is considered as 0, +# meaning that the dags are never paused out by default. +# +# Variable: AIRFLOW__CORE__MAX_CONSECUTIVE_FAILED_DAG_RUNS_PER_DAG +# +max_consecutive_failed_dag_runs_per_dag = 0 + +# The name of the method used in order to start Python processes via the multiprocessing module. +# This corresponds directly with the options available in the Python docs: +# `multiprocessing.set_start_method +# `__ +# must be one of the values returned by `multiprocessing.get_all_start_methods() +# `__. +# +# Example: mp_start_method = fork +# +# Variable: AIRFLOW__CORE__MP_START_METHOD +# +# mp_start_method = + +# Whether to load the DAG examples that ship with Airflow. It's good to +# get started, but you probably want to set this to ``False`` in a production +# environment +# +# Variable: AIRFLOW__CORE__LOAD_EXAMPLES +# +load_examples = True + +# Path to the folder containing Airflow plugins +# +# Variable: AIRFLOW__CORE__PLUGINS_FOLDER +# +plugins_folder = /Users/palaeosaurus/Data-Projects/2024/sensors-and-more/plugins + +# Should tasks be executed via forking of the parent process +# +# * ``False``: Execute via forking of the parent process +# * ``True``: Spawning a new python process, slower than fork, but means plugin changes picked +# up by tasks straight away +# +# Variable: AIRFLOW__CORE__EXECUTE_TASKS_NEW_PYTHON_INTERPRETER +# +execute_tasks_new_python_interpreter = False + +# Secret key to save connection passwords in the db +# +# Variable: AIRFLOW__CORE__FERNET_KEY +# +fernet_key = + +# Whether to disable pickling dags +# +# Variable: AIRFLOW__CORE__DONOT_PICKLE +# +donot_pickle = True + +# How long before timing out a python file import +# +# Variable: AIRFLOW__CORE__DAGBAG_IMPORT_TIMEOUT +# +dagbag_import_timeout = 30.0 + +# Should a traceback be shown in the UI for dagbag import errors, +# instead of just the exception message +# +# Variable: AIRFLOW__CORE__DAGBAG_IMPORT_ERROR_TRACEBACKS +# +dagbag_import_error_tracebacks = True + +# If tracebacks are shown, how many entries from the traceback should be shown +# +# Variable: AIRFLOW__CORE__DAGBAG_IMPORT_ERROR_TRACEBACK_DEPTH +# +dagbag_import_error_traceback_depth = 2 + +# How long before timing out a DagFileProcessor, which processes a dag file +# +# Variable: AIRFLOW__CORE__DAG_FILE_PROCESSOR_TIMEOUT +# +dag_file_processor_timeout = 50 + +# The class to use for running task instances in a subprocess. +# Choices include StandardTaskRunner, CgroupTaskRunner or the full import path to the class +# when using a custom task runner. +# +# Variable: AIRFLOW__CORE__TASK_RUNNER +# +task_runner = StandardTaskRunner + +# If set, tasks without a ``run_as_user`` argument will be run with this user +# Can be used to de-elevate a sudo user running Airflow when executing tasks +# +# Variable: AIRFLOW__CORE__DEFAULT_IMPERSONATION +# +default_impersonation = + +# What security module to use (for example kerberos) +# +# Variable: AIRFLOW__CORE__SECURITY +# +security = + +# Turn unit test mode on (overwrites many configuration options with test +# values at runtime) +# +# Variable: AIRFLOW__CORE__UNIT_TEST_MODE +# +unit_test_mode = False + +# Whether to enable pickling for xcom (note that this is insecure and allows for +# RCE exploits). +# +# Variable: AIRFLOW__CORE__ENABLE_XCOM_PICKLING +# +enable_xcom_pickling = False + +# What classes can be imported during deserialization. This is a multi line value. +# The individual items will be parsed as a pattern to a glob function. +# Python built-in classes (like dict) are always allowed. +# +# Variable: AIRFLOW__CORE__ALLOWED_DESERIALIZATION_CLASSES +# +allowed_deserialization_classes = airflow.* + +# What classes can be imported during deserialization. This is a multi line value. +# The individual items will be parsed as regexp patterns. +# This is a secondary option to ``[core] allowed_deserialization_classes``. +# +# Variable: AIRFLOW__CORE__ALLOWED_DESERIALIZATION_CLASSES_REGEXP +# +allowed_deserialization_classes_regexp = + +# When a task is killed forcefully, this is the amount of time in seconds that +# it has to cleanup after it is sent a SIGTERM, before it is SIGKILLED +# +# Variable: AIRFLOW__CORE__KILLED_TASK_CLEANUP_TIME +# +killed_task_cleanup_time = 60 + +# Whether to override params with dag_run.conf. If you pass some key-value pairs +# through ``airflow dags backfill -c`` or +# ``airflow dags trigger -c``, the key-value pairs will override the existing ones in params. +# +# Variable: AIRFLOW__CORE__DAG_RUN_CONF_OVERRIDES_PARAMS +# +dag_run_conf_overrides_params = True + +# If enabled, Airflow will only scan files containing both ``DAG`` and ``airflow`` (case-insensitive). +# +# Variable: AIRFLOW__CORE__DAG_DISCOVERY_SAFE_MODE +# +dag_discovery_safe_mode = True + +# The pattern syntax used in the +# `.airflowignore +# `__ +# files in the DAG directories. Valid values are ``regexp`` or ``glob``. +# +# Variable: AIRFLOW__CORE__DAG_IGNORE_FILE_SYNTAX +# +dag_ignore_file_syntax = regexp + +# The number of retries each task is going to have by default. Can be overridden at dag or task level. +# +# Variable: AIRFLOW__CORE__DEFAULT_TASK_RETRIES +# +default_task_retries = 0 + +# The number of seconds each task is going to wait by default between retries. Can be overridden at +# dag or task level. +# +# Variable: AIRFLOW__CORE__DEFAULT_TASK_RETRY_DELAY +# +default_task_retry_delay = 300 + +# The maximum delay (in seconds) each task is going to wait by default between retries. +# This is a global setting and cannot be overridden at task or DAG level. +# +# Variable: AIRFLOW__CORE__MAX_TASK_RETRY_DELAY +# +max_task_retry_delay = 86400 + +# The weighting method used for the effective total priority weight of the task +# +# Variable: AIRFLOW__CORE__DEFAULT_TASK_WEIGHT_RULE +# +default_task_weight_rule = downstream + +# The default task execution_timeout value for the operators. Expected an integer value to +# be passed into timedelta as seconds. If not specified, then the value is considered as None, +# meaning that the operators are never timed out by default. +# +# Variable: AIRFLOW__CORE__DEFAULT_TASK_EXECUTION_TIMEOUT +# +default_task_execution_timeout = + +# Updating serialized DAG can not be faster than a minimum interval to reduce database write rate. +# +# Variable: AIRFLOW__CORE__MIN_SERIALIZED_DAG_UPDATE_INTERVAL +# +min_serialized_dag_update_interval = 30 + +# If ``True``, serialized DAGs are compressed before writing to DB. +# +# .. note:: +# +# This will disable the DAG dependencies view +# +# Variable: AIRFLOW__CORE__COMPRESS_SERIALIZED_DAGS +# +compress_serialized_dags = False + +# Fetching serialized DAG can not be faster than a minimum interval to reduce database +# read rate. This config controls when your DAGs are updated in the Webserver +# +# Variable: AIRFLOW__CORE__MIN_SERIALIZED_DAG_FETCH_INTERVAL +# +min_serialized_dag_fetch_interval = 10 + +# Maximum number of Rendered Task Instance Fields (Template Fields) per task to store +# in the Database. +# All the template_fields for each of Task Instance are stored in the Database. +# Keeping this number small may cause an error when you try to view ``Rendered`` tab in +# TaskInstance view for older tasks. +# +# Variable: AIRFLOW__CORE__MAX_NUM_RENDERED_TI_FIELDS_PER_TASK +# +max_num_rendered_ti_fields_per_task = 30 + +# On each dagrun check against defined SLAs +# +# Variable: AIRFLOW__CORE__CHECK_SLAS +# +check_slas = True + +# Path to custom XCom class that will be used to store and resolve operators results +# +# Example: xcom_backend = path.to.CustomXCom +# +# Variable: AIRFLOW__CORE__XCOM_BACKEND +# +xcom_backend = airflow.models.xcom.BaseXCom + +# By default Airflow plugins are lazily-loaded (only loaded when required). Set it to ``False``, +# if you want to load plugins whenever 'airflow' is invoked via cli or loaded from module. +# +# Variable: AIRFLOW__CORE__LAZY_LOAD_PLUGINS +# +lazy_load_plugins = True + +# By default Airflow providers are lazily-discovered (discovery and imports happen only when required). +# Set it to ``False``, if you want to discover providers whenever 'airflow' is invoked via cli or +# loaded from module. +# +# Variable: AIRFLOW__CORE__LAZY_DISCOVER_PROVIDERS +# +lazy_discover_providers = True + +# Hide sensitive **Variables** or **Connection extra json keys** from UI +# and task logs when set to ``True`` +# +# .. note:: +# +# Connection passwords are always hidden in logs +# +# Variable: AIRFLOW__CORE__HIDE_SENSITIVE_VAR_CONN_FIELDS +# +hide_sensitive_var_conn_fields = True + +# A comma-separated list of extra sensitive keywords to look for in variables names or connection's +# extra JSON. +# +# Variable: AIRFLOW__CORE__SENSITIVE_VAR_CONN_NAMES +# +sensitive_var_conn_names = + +# Task Slot counts for ``default_pool``. This setting would not have any effect in an existing +# deployment where the ``default_pool`` is already created. For existing deployments, users can +# change the number of slots using Webserver, API or the CLI +# +# Variable: AIRFLOW__CORE__DEFAULT_POOL_TASK_SLOT_COUNT +# +default_pool_task_slot_count = 128 + +# The maximum list/dict length an XCom can push to trigger task mapping. If the pushed list/dict has a +# length exceeding this value, the task pushing the XCom will be failed automatically to prevent the +# mapped tasks from clogging the scheduler. +# +# Variable: AIRFLOW__CORE__MAX_MAP_LENGTH +# +max_map_length = 1024 + +# The default umask to use for process when run in daemon mode (scheduler, worker, etc.) +# +# This controls the file-creation mode mask which determines the initial value of file permission bits +# for newly created files. +# +# This value is treated as an octal-integer. +# +# Variable: AIRFLOW__CORE__DAEMON_UMASK +# +daemon_umask = 0o077 + +# Class to use as dataset manager. +# +# Example: dataset_manager_class = airflow.datasets.manager.DatasetManager +# +# Variable: AIRFLOW__CORE__DATASET_MANAGER_CLASS +# +# dataset_manager_class = + +# Kwargs to supply to dataset manager. +# +# Example: dataset_manager_kwargs = {"some_param": "some_value"} +# +# Variable: AIRFLOW__CORE__DATASET_MANAGER_KWARGS +# +# dataset_manager_kwargs = + +# Dataset URI validation should raise an exception if it is not compliant with AIP-60. +# By default this configuration is false, meaning that Airflow 2.x only warns the user. +# In Airflow 3, this configuration will be enabled by default. +# +# Variable: AIRFLOW__CORE__STRICT_DATASET_URI_VALIDATION +# +strict_dataset_uri_validation = False + +# (experimental) Whether components should use Airflow Internal API for DB connectivity. +# +# Variable: AIRFLOW__CORE__DATABASE_ACCESS_ISOLATION +# +database_access_isolation = False + +# (experimental) Airflow Internal API url. +# Only used if ``[core] database_access_isolation`` is ``True``. +# +# Example: internal_api_url = http://localhost:8080 +# +# Variable: AIRFLOW__CORE__INTERNAL_API_URL +# +# internal_api_url = + +# The ability to allow testing connections across Airflow UI, API and CLI. +# Supported options: ``Disabled``, ``Enabled``, ``Hidden``. Default: Disabled +# Disabled - Disables the test connection functionality and disables the Test Connection button in UI. +# Enabled - Enables the test connection functionality and shows the Test Connection button in UI. +# Hidden - Disables the test connection functionality and hides the Test Connection button in UI. +# Before setting this to Enabled, make sure that you review the users who are able to add/edit +# connections and ensure they are trusted. Connection testing can be done maliciously leading to +# undesired and insecure outcomes. +# See `Airflow Security Model: Capabilities of authenticated UI users +# `__ +# for more details. +# +# Variable: AIRFLOW__CORE__TEST_CONNECTION +# +test_connection = Disabled + +# The maximum length of the rendered template field. If the value to be stored in the +# rendered template field exceeds this size, it's redacted. +# +# Variable: AIRFLOW__CORE__MAX_TEMPLATED_FIELD_LENGTH +# +max_templated_field_length = 4096 + +[database] +# Path to the ``alembic.ini`` file. You can either provide the file path relative +# to the Airflow home directory or the absolute path if it is located elsewhere. +# +# Variable: AIRFLOW__DATABASE__ALEMBIC_INI_FILE_PATH +# +alembic_ini_file_path = alembic.ini + +# The SQLAlchemy connection string to the metadata database. +# SQLAlchemy supports many different database engines. +# See: `Set up a Database Backend: Database URI +# `__ +# for more details. +# +# Variable: AIRFLOW__DATABASE__SQL_ALCHEMY_CONN +# +sql_alchemy_conn = sqlite:////Users/palaeosaurus/Data-Projects/2024/sensors-and-more/airflow.db + +# Extra engine specific keyword args passed to SQLAlchemy's create_engine, as a JSON-encoded value +# +# Example: sql_alchemy_engine_args = {"arg1": true} +# +# Variable: AIRFLOW__DATABASE__SQL_ALCHEMY_ENGINE_ARGS +# +# sql_alchemy_engine_args = + +# The encoding for the databases +# +# Variable: AIRFLOW__DATABASE__SQL_ENGINE_ENCODING +# +sql_engine_encoding = utf-8 + +# Collation for ``dag_id``, ``task_id``, ``key``, ``external_executor_id`` columns +# in case they have different encoding. +# By default this collation is the same as the database collation, however for ``mysql`` and ``mariadb`` +# the default is ``utf8mb3_bin`` so that the index sizes of our index keys will not exceed +# the maximum size of allowed index when collation is set to ``utf8mb4`` variant, see +# `GitHub Issue Comment `__ +# for more details. +# +# Variable: AIRFLOW__DATABASE__SQL_ENGINE_COLLATION_FOR_IDS +# +# sql_engine_collation_for_ids = + +# If SQLAlchemy should pool database connections. +# +# Variable: AIRFLOW__DATABASE__SQL_ALCHEMY_POOL_ENABLED +# +sql_alchemy_pool_enabled = True + +# The SQLAlchemy pool size is the maximum number of database connections +# in the pool. 0 indicates no limit. +# +# Variable: AIRFLOW__DATABASE__SQL_ALCHEMY_POOL_SIZE +# +sql_alchemy_pool_size = 5 + +# The maximum overflow size of the pool. +# When the number of checked-out connections reaches the size set in pool_size, +# additional connections will be returned up to this limit. +# When those additional connections are returned to the pool, they are disconnected and discarded. +# It follows then that the total number of simultaneous connections the pool will allow +# is **pool_size** + **max_overflow**, +# and the total number of "sleeping" connections the pool will allow is pool_size. +# max_overflow can be set to ``-1`` to indicate no overflow limit; +# no limit will be placed on the total number of concurrent connections. Defaults to ``10``. +# +# Variable: AIRFLOW__DATABASE__SQL_ALCHEMY_MAX_OVERFLOW +# +sql_alchemy_max_overflow = 10 + +# The SQLAlchemy pool recycle is the number of seconds a connection +# can be idle in the pool before it is invalidated. This config does +# not apply to sqlite. If the number of DB connections is ever exceeded, +# a lower config value will allow the system to recover faster. +# +# Variable: AIRFLOW__DATABASE__SQL_ALCHEMY_POOL_RECYCLE +# +sql_alchemy_pool_recycle = 1800 + +# Check connection at the start of each connection pool checkout. +# Typically, this is a simple statement like "SELECT 1". +# See `SQLAlchemy Pooling: Disconnect Handling - Pessimistic +# `__ +# for more details. +# +# Variable: AIRFLOW__DATABASE__SQL_ALCHEMY_POOL_PRE_PING +# +sql_alchemy_pool_pre_ping = True + +# The schema to use for the metadata database. +# SQLAlchemy supports databases with the concept of multiple schemas. +# +# Variable: AIRFLOW__DATABASE__SQL_ALCHEMY_SCHEMA +# +sql_alchemy_schema = + +# Import path for connect args in SQLAlchemy. Defaults to an empty dict. +# This is useful when you want to configure db engine args that SQLAlchemy won't parse +# in connection string. This can be set by passing a dictionary containing the create engine parameters. +# For more details about passing create engine parameters (keepalives variables, timeout etc) +# in Postgres DB Backend see `Setting up a PostgreSQL Database +# `__ +# e.g ``connect_args={"timeout":30}`` can be defined in ``airflow_local_settings.py`` and +# can be imported as shown below +# +# Example: sql_alchemy_connect_args = airflow_local_settings.connect_args +# +# Variable: AIRFLOW__DATABASE__SQL_ALCHEMY_CONNECT_ARGS +# +# sql_alchemy_connect_args = + +# Whether to load the default connections that ship with Airflow when ``airflow db init`` is called. +# It's good to get started, but you probably want to set this to ``False`` in a production environment. +# +# Variable: AIRFLOW__DATABASE__LOAD_DEFAULT_CONNECTIONS +# +load_default_connections = True + +# Number of times the code should be retried in case of DB Operational Errors. +# Not all transactions will be retried as it can cause undesired state. +# Currently it is only used in ``DagFileProcessor.process_file`` to retry ``dagbag.sync_to_db``. +# +# Variable: AIRFLOW__DATABASE__MAX_DB_RETRIES +# +max_db_retries = 3 + +# Whether to run alembic migrations during Airflow start up. Sometimes this operation can be expensive, +# and the users can assert the correct version through other means (e.g. through a Helm chart). +# Accepts ``True`` or ``False``. +# +# Variable: AIRFLOW__DATABASE__CHECK_MIGRATIONS +# +check_migrations = True + +[logging] +# The folder where airflow should store its log files. +# This path must be absolute. +# There are a few existing configurations that assume this is set to the default. +# If you choose to override this you may need to update the +# ``[logging] dag_processor_manager_log_location`` and +# ``[logging] child_process_log_directory settings`` as well. +# +# Variable: AIRFLOW__LOGGING__BASE_LOG_FOLDER +# +base_log_folder = /Users/palaeosaurus/Data-Projects/2024/sensors-and-more/logs + +# Airflow can store logs remotely in AWS S3, Google Cloud Storage or Elastic Search. +# Set this to ``True`` if you want to enable remote logging. +# +# Variable: AIRFLOW__LOGGING__REMOTE_LOGGING +# +remote_logging = False + +# Users must supply an Airflow connection id that provides access to the storage +# location. Depending on your remote logging service, this may only be used for +# reading logs, not writing them. +# +# Variable: AIRFLOW__LOGGING__REMOTE_LOG_CONN_ID +# +remote_log_conn_id = + +# Whether the local log files for GCS, S3, WASB and OSS remote logging should be deleted after +# they are uploaded to the remote location. +# +# Variable: AIRFLOW__LOGGING__DELETE_LOCAL_LOGS +# +delete_local_logs = False + +# Path to Google Credential JSON file. If omitted, authorization based on `the Application Default +# Credentials +# `__ will +# be used. +# +# Variable: AIRFLOW__LOGGING__GOOGLE_KEY_PATH +# +google_key_path = + +# Storage bucket URL for remote logging +# S3 buckets should start with **s3://** +# Cloudwatch log groups should start with **cloudwatch://** +# GCS buckets should start with **gs://** +# WASB buckets should start with **wasb** just to help Airflow select correct handler +# Stackdriver logs should start with **stackdriver://** +# +# Variable: AIRFLOW__LOGGING__REMOTE_BASE_LOG_FOLDER +# +remote_base_log_folder = + +# The remote_task_handler_kwargs param is loaded into a dictionary and passed to the ``__init__`` +# of remote task handler and it overrides the values provided by Airflow config. For example if you set +# ``delete_local_logs=False`` and you provide ``{"delete_local_copy": true}``, then the local +# log files will be deleted after they are uploaded to remote location. +# +# Example: remote_task_handler_kwargs = {"delete_local_copy": true} +# +# Variable: AIRFLOW__LOGGING__REMOTE_TASK_HANDLER_KWARGS +# +remote_task_handler_kwargs = + +# Use server-side encryption for logs stored in S3 +# +# Variable: AIRFLOW__LOGGING__ENCRYPT_S3_LOGS +# +encrypt_s3_logs = False + +# Logging level. +# +# Supported values: ``CRITICAL``, ``ERROR``, ``WARNING``, ``INFO``, ``DEBUG``. +# +# Variable: AIRFLOW__LOGGING__LOGGING_LEVEL +# +logging_level = INFO + +# Logging level for celery. If not set, it uses the value of logging_level +# +# Supported values: ``CRITICAL``, ``ERROR``, ``WARNING``, ``INFO``, ``DEBUG``. +# +# Variable: AIRFLOW__LOGGING__CELERY_LOGGING_LEVEL +# +celery_logging_level = + +# Logging level for Flask-appbuilder UI. +# +# Supported values: ``CRITICAL``, ``ERROR``, ``WARNING``, ``INFO``, ``DEBUG``. +# +# Variable: AIRFLOW__LOGGING__FAB_LOGGING_LEVEL +# +fab_logging_level = WARNING + +# Logging class +# Specify the class that will specify the logging configuration +# This class has to be on the python classpath +# +# Example: logging_config_class = my.path.default_local_settings.LOGGING_CONFIG +# +# Variable: AIRFLOW__LOGGING__LOGGING_CONFIG_CLASS +# +logging_config_class = + +# Flag to enable/disable Colored logs in Console +# Colour the logs when the controlling terminal is a TTY. +# +# Variable: AIRFLOW__LOGGING__COLORED_CONSOLE_LOG +# +colored_console_log = True + +# Log format for when Colored logs is enabled +# +# Variable: AIRFLOW__LOGGING__COLORED_LOG_FORMAT +# +colored_log_format = [%%(blue)s%%(asctime)s%%(reset)s] {%%(blue)s%%(filename)s:%%(reset)s%%(lineno)d} %%(log_color)s%%(levelname)s%%(reset)s - %%(log_color)s%%(message)s%%(reset)s + +# Specifies the class utilized by Airflow to implement colored logging +# +# Variable: AIRFLOW__LOGGING__COLORED_FORMATTER_CLASS +# +colored_formatter_class = airflow.utils.log.colored_log.CustomTTYColoredFormatter + +# Format of Log line +# +# Variable: AIRFLOW__LOGGING__LOG_FORMAT +# +log_format = [%%(asctime)s] {%%(filename)s:%%(lineno)d} %%(levelname)s - %%(message)s + +# Defines the format of log messages for simple logging configuration +# +# Variable: AIRFLOW__LOGGING__SIMPLE_LOG_FORMAT +# +simple_log_format = %%(asctime)s %%(levelname)s - %%(message)s + +# Where to send dag parser logs. If "file", logs are sent to log files defined by child_process_log_directory. +# +# Variable: AIRFLOW__LOGGING__DAG_PROCESSOR_LOG_TARGET +# +dag_processor_log_target = file + +# Format of Dag Processor Log line +# +# Variable: AIRFLOW__LOGGING__DAG_PROCESSOR_LOG_FORMAT +# +dag_processor_log_format = [%%(asctime)s] [SOURCE:DAG_PROCESSOR] {%%(filename)s:%%(lineno)d} %%(levelname)s - %%(message)s + +# Determines the formatter class used by Airflow for structuring its log messages +# The default formatter class is timezone-aware, which means that timestamps attached to log entries +# will be adjusted to reflect the local timezone of the Airflow instance +# +# Variable: AIRFLOW__LOGGING__LOG_FORMATTER_CLASS +# +log_formatter_class = airflow.utils.log.timezone_aware.TimezoneAware + +# An import path to a function to add adaptations of each secret added with +# ``airflow.utils.log.secrets_masker.mask_secret`` to be masked in log messages. The given function +# is expected to require a single parameter: the secret to be adapted. It may return a +# single adaptation of the secret or an iterable of adaptations to each be masked as secrets. +# The original secret will be masked as well as any adaptations returned. +# +# Example: secret_mask_adapter = urllib.parse.quote +# +# Variable: AIRFLOW__LOGGING__SECRET_MASK_ADAPTER +# +secret_mask_adapter = + +# Specify prefix pattern like mentioned below with stream handler ``TaskHandlerWithCustomFormatter`` +# +# Example: task_log_prefix_template = {{ti.dag_id}}-{{ti.task_id}}-{{execution_date}}-{{ti.try_number}} +# +# Variable: AIRFLOW__LOGGING__TASK_LOG_PREFIX_TEMPLATE +# +task_log_prefix_template = + +# Formatting for how airflow generates file names/paths for each task run. +# +# Variable: AIRFLOW__LOGGING__LOG_FILENAME_TEMPLATE +# +log_filename_template = dag_id={{ ti.dag_id }}/run_id={{ ti.run_id }}/task_id={{ ti.task_id }}/{%% if ti.map_index >= 0 %%}map_index={{ ti.map_index }}/{%% endif %%}attempt={{ try_number }}.log + +# Formatting for how airflow generates file names for log +# +# Variable: AIRFLOW__LOGGING__LOG_PROCESSOR_FILENAME_TEMPLATE +# +log_processor_filename_template = {{ filename }}.log + +# Full path of dag_processor_manager logfile. +# +# Variable: AIRFLOW__LOGGING__DAG_PROCESSOR_MANAGER_LOG_LOCATION +# +dag_processor_manager_log_location = /Users/palaeosaurus/Data-Projects/2024/sensors-and-more/logs/dag_processor_manager/dag_processor_manager.log + +# Whether DAG processor manager will write logs to stdout +# +# Variable: AIRFLOW__LOGGING__DAG_PROCESSOR_MANAGER_LOG_STDOUT +# +dag_processor_manager_log_stdout = False + +# Name of handler to read task instance logs. +# Defaults to use ``task`` handler. +# +# Variable: AIRFLOW__LOGGING__TASK_LOG_READER +# +task_log_reader = task + +# A comma\-separated list of third-party logger names that will be configured to print messages to +# consoles\. +# +# Example: extra_logger_names = connexion,sqlalchemy +# +# Variable: AIRFLOW__LOGGING__EXTRA_LOGGER_NAMES +# +extra_logger_names = + +# When you start an Airflow worker, Airflow starts a tiny web server +# subprocess to serve the workers local log files to the airflow main +# web server, who then builds pages and sends them to users. This defines +# the port on which the logs are served. It needs to be unused, and open +# visible from the main web server to connect into the workers. +# +# Variable: AIRFLOW__LOGGING__WORKER_LOG_SERVER_PORT +# +worker_log_server_port = 8793 + +# Port to serve logs from for triggerer. +# See ``[logging] worker_log_server_port`` description for more info. +# +# Variable: AIRFLOW__LOGGING__TRIGGER_LOG_SERVER_PORT +# +trigger_log_server_port = 8794 + +# We must parse timestamps to interleave logs between trigger and task. To do so, +# we need to parse timestamps in log files. In case your log format is non-standard, +# you may provide import path to callable which takes a string log line and returns +# the timestamp (datetime.datetime compatible). +# +# Example: interleave_timestamp_parser = path.to.my_func +# +# Variable: AIRFLOW__LOGGING__INTERLEAVE_TIMESTAMP_PARSER +# +# interleave_timestamp_parser = + +# Permissions in the form or of octal string as understood by chmod. The permissions are important +# when you use impersonation, when logs are written by a different user than airflow. The most secure +# way of configuring it in this case is to add both users to the same group and make it the default +# group of both users. Group-writeable logs are default in airflow, but you might decide that you are +# OK with having the logs other-writeable, in which case you should set it to ``0o777``. You might +# decide to add more security if you do not use impersonation and change it to ``0o755`` to make it +# only owner-writeable. You can also make it just readable only for owner by changing it to ``0o700`` +# if all the access (read/write) for your logs happens from the same user. +# +# Example: file_task_handler_new_folder_permissions = 0o775 +# +# Variable: AIRFLOW__LOGGING__FILE_TASK_HANDLER_NEW_FOLDER_PERMISSIONS +# +file_task_handler_new_folder_permissions = 0o775 + +# Permissions in the form or of octal string as understood by chmod. The permissions are important +# when you use impersonation, when logs are written by a different user than airflow. The most secure +# way of configuring it in this case is to add both users to the same group and make it the default +# group of both users. Group-writeable logs are default in airflow, but you might decide that you are +# OK with having the logs other-writeable, in which case you should set it to ``0o666``. You might +# decide to add more security if you do not use impersonation and change it to ``0o644`` to make it +# only owner-writeable. You can also make it just readable only for owner by changing it to ``0o600`` +# if all the access (read/write) for your logs happens from the same user. +# +# Example: file_task_handler_new_file_permissions = 0o664 +# +# Variable: AIRFLOW__LOGGING__FILE_TASK_HANDLER_NEW_FILE_PERMISSIONS +# +file_task_handler_new_file_permissions = 0o664 + +# By default Celery sends all logs into stderr. +# If enabled any previous logging handlers will get *removed*. +# With this option AirFlow will create new handlers +# and send low level logs like INFO and WARNING to stdout, +# while sending higher severity logs to stderr. +# +# Variable: AIRFLOW__LOGGING__CELERY_STDOUT_STDERR_SEPARATION +# +celery_stdout_stderr_separation = False + +# If enabled, Airflow may ship messages to task logs from outside the task run context, e.g. from +# the scheduler, executor, or callback execution context. This can help in circumstances such as +# when there's something blocking the execution of the task and ordinarily there may be no task +# logs at all. +# This is set to ``True`` by default. If you encounter issues with this feature +# (e.g. scheduler performance issues) it can be disabled. +# +# Variable: AIRFLOW__LOGGING__ENABLE_TASK_CONTEXT_LOGGER +# +enable_task_context_logger = True + +[metrics] +# `StatsD `__ integration settings. + +# If true, ``[metrics] metrics_allow_list`` and ``[metrics] metrics_block_list`` will use +# regex pattern matching anywhere within the metric name instead of only prefix matching +# at the start of the name. +# +# Variable: AIRFLOW__METRICS__METRICS_USE_PATTERN_MATCH +# +metrics_use_pattern_match = False + +# Configure an allow list (comma separated string) to send only certain metrics. +# If ``[metrics] metrics_use_pattern_match`` is ``false``, match only the exact metric name prefix. +# If ``[metrics] metrics_use_pattern_match`` is ``true``, provide regex patterns to match. +# +# Example: metrics_allow_list = "scheduler,executor,dagrun,pool,triggerer,celery" or "^scheduler,^executor,heartbeat|timeout" +# +# Variable: AIRFLOW__METRICS__METRICS_ALLOW_LIST +# +metrics_allow_list = + +# Configure a block list (comma separated string) to block certain metrics from being emitted. +# If ``[metrics] metrics_allow_list`` and ``[metrics] metrics_block_list`` are both configured, +# ``[metrics] metrics_block_list`` is ignored. +# +# If ``[metrics] metrics_use_pattern_match`` is ``false``, match only the exact metric name prefix. +# +# If ``[metrics] metrics_use_pattern_match`` is ``true``, provide regex patterns to match. +# +# Example: metrics_block_list = "scheduler,executor,dagrun,pool,triggerer,celery" or "^scheduler,^executor,heartbeat|timeout" +# +# Variable: AIRFLOW__METRICS__METRICS_BLOCK_LIST +# +metrics_block_list = + +# Enables sending metrics to StatsD. +# +# Variable: AIRFLOW__METRICS__STATSD_ON +# +statsd_on = False + +# Specifies the host address where the StatsD daemon (or server) is running +# +# Variable: AIRFLOW__METRICS__STATSD_HOST +# +statsd_host = localhost + +# Specifies the port on which the StatsD daemon (or server) is listening to +# +# Variable: AIRFLOW__METRICS__STATSD_PORT +# +statsd_port = 8125 + +# Defines the namespace for all metrics sent from Airflow to StatsD +# +# Variable: AIRFLOW__METRICS__STATSD_PREFIX +# +statsd_prefix = airflow + +# A function that validate the StatsD stat name, apply changes to the stat name if necessary and return +# the transformed stat name. +# +# The function should have the following signature +# +# .. code-block:: python +# +# def func_name(stat_name: str) -> str: ... +# +# Variable: AIRFLOW__METRICS__STAT_NAME_HANDLER +# +stat_name_handler = + +# To enable datadog integration to send airflow metrics. +# +# Variable: AIRFLOW__METRICS__STATSD_DATADOG_ENABLED +# +statsd_datadog_enabled = False + +# List of datadog tags attached to all metrics(e.g: ``key1:value1,key2:value2``) +# +# Variable: AIRFLOW__METRICS__STATSD_DATADOG_TAGS +# +statsd_datadog_tags = + +# Set to ``False`` to disable metadata tags for some of the emitted metrics +# +# Variable: AIRFLOW__METRICS__STATSD_DATADOG_METRICS_TAGS +# +statsd_datadog_metrics_tags = True + +# If you want to utilise your own custom StatsD client set the relevant +# module path below. +# Note: The module path must exist on your +# `PYTHONPATH ` +# for Airflow to pick it up +# +# Variable: AIRFLOW__METRICS__STATSD_CUSTOM_CLIENT_PATH +# +# statsd_custom_client_path = + +# If you want to avoid sending all the available metrics tags to StatsD, +# you can configure a block list of prefixes (comma separated) to filter out metric tags +# that start with the elements of the list (e.g: ``job_id,run_id``) +# +# Example: statsd_disabled_tags = job_id,run_id,dag_id,task_id +# +# Variable: AIRFLOW__METRICS__STATSD_DISABLED_TAGS +# +statsd_disabled_tags = job_id,run_id + +# To enable sending Airflow metrics with StatsD-Influxdb tagging convention. +# +# Variable: AIRFLOW__METRICS__STATSD_INFLUXDB_ENABLED +# +statsd_influxdb_enabled = False + +# Enables sending metrics to OpenTelemetry. +# +# Variable: AIRFLOW__METRICS__OTEL_ON +# +otel_on = False + +# Specifies the hostname or IP address of the OpenTelemetry Collector to which Airflow sends +# metrics and traces. +# +# Variable: AIRFLOW__METRICS__OTEL_HOST +# +otel_host = localhost + +# Specifies the port of the OpenTelemetry Collector that is listening to. +# +# Variable: AIRFLOW__METRICS__OTEL_PORT +# +otel_port = 8889 + +# The prefix for the Airflow metrics. +# +# Variable: AIRFLOW__METRICS__OTEL_PREFIX +# +otel_prefix = airflow + +# Defines the interval, in milliseconds, at which Airflow sends batches of metrics and traces +# to the configured OpenTelemetry Collector. +# +# Variable: AIRFLOW__METRICS__OTEL_INTERVAL_MILLISECONDS +# +otel_interval_milliseconds = 60000 + +# If ``True``, all metrics are also emitted to the console. Defaults to ``False``. +# +# Variable: AIRFLOW__METRICS__OTEL_DEBUGGING_ON +# +otel_debugging_on = False + +# If ``True``, SSL will be enabled. Defaults to ``False``. +# To establish an HTTPS connection to the OpenTelemetry collector, +# you need to configure the SSL certificate and key within the OpenTelemetry collector's +# ``config.yml`` file. +# +# Variable: AIRFLOW__METRICS__OTEL_SSL_ACTIVE +# +otel_ssl_active = False + +[secrets] +# Full class name of secrets backend to enable (will precede env vars and metastore in search path) +# +# Example: backend = airflow.providers.amazon.aws.secrets.systems_manager.SystemsManagerParameterStoreBackend +# +# Variable: AIRFLOW__SECRETS__BACKEND +# +backend = + +# The backend_kwargs param is loaded into a dictionary and passed to ``__init__`` +# of secrets backend class. See documentation for the secrets backend you are using. +# JSON is expected. +# +# Example for AWS Systems Manager ParameterStore: +# ``{"connections_prefix": "/airflow/connections", "profile_name": "default"}`` +# +# Variable: AIRFLOW__SECRETS__BACKEND_KWARGS +# +backend_kwargs = + +# .. note:: |experimental| +# +# Enables local caching of Variables, when parsing DAGs only. +# Using this option can make dag parsing faster if Variables are used in top level code, at the expense +# of longer propagation time for changes. +# Please note that this cache concerns only the DAG parsing step. There is no caching in place when DAG +# tasks are run. +# +# Variable: AIRFLOW__SECRETS__USE_CACHE +# +use_cache = False + +# .. note:: |experimental| +# +# When the cache is enabled, this is the duration for which we consider an entry in the cache to be +# valid. Entries are refreshed if they are older than this many seconds. +# It means that when the cache is enabled, this is the maximum amount of time you need to wait to see a +# Variable change take effect. +# +# Variable: AIRFLOW__SECRETS__CACHE_TTL_SECONDS +# +cache_ttl_seconds = 900 + +[cli] +# In what way should the cli access the API. The LocalClient will use the +# database directly, while the json_client will use the api running on the +# webserver +# +# Variable: AIRFLOW__CLI__API_CLIENT +# +api_client = airflow.api.client.local_client + +# If you set web_server_url_prefix, do NOT forget to append it here, ex: +# ``endpoint_url = http://localhost:8080/myroot`` +# So api will look like: ``http://localhost:8080/myroot/api/experimental/...`` +# +# Variable: AIRFLOW__CLI__ENDPOINT_URL +# +endpoint_url = http://localhost:8080 + +[debug] +# Used only with ``DebugExecutor``. If set to ``True`` DAG will fail with first +# failed task. Helpful for debugging purposes. +# +# Variable: AIRFLOW__DEBUG__FAIL_FAST +# +fail_fast = False + +[api] +# Enables the deprecated experimental API. Please note that these API endpoints do not have +# access control. An authenticated user has full access. +# +# .. warning:: +# +# This `Experimental REST API +# `__ is +# deprecated since version 2.0. Please consider using +# `the Stable REST API +# `__. +# For more information on migration, see +# `RELEASE_NOTES.rst `_ +# +# Variable: AIRFLOW__API__ENABLE_EXPERIMENTAL_API +# +enable_experimental_api = False + +# Comma separated list of auth backends to authenticate users of the API. See +# `Security: API +# `__ for possible values. +# ("airflow.api.auth.backend.default" allows all requests for historic reasons) +# +# Variable: AIRFLOW__API__AUTH_BACKENDS +# +auth_backends = airflow.api.auth.backend.session + +# Used to set the maximum page limit for API requests. If limit passed as param +# is greater than maximum page limit, it will be ignored and maximum page limit value +# will be set as the limit +# +# Variable: AIRFLOW__API__MAXIMUM_PAGE_LIMIT +# +maximum_page_limit = 100 + +# Used to set the default page limit when limit param is zero or not provided in API +# requests. Otherwise if positive integer is passed in the API requests as limit, the +# smallest number of user given limit or maximum page limit is taken as limit. +# +# Variable: AIRFLOW__API__FALLBACK_PAGE_LIMIT +# +fallback_page_limit = 100 + +# The intended audience for JWT token credentials used for authorization. This value must match on the client and server sides. If empty, audience will not be tested. +# +# Example: google_oauth2_audience = project-id-random-value.apps.googleusercontent.com +# +# Variable: AIRFLOW__API__GOOGLE_OAUTH2_AUDIENCE +# +google_oauth2_audience = + +# Path to Google Cloud Service Account key file (JSON). If omitted, authorization based on +# `the Application Default Credentials +# `__ will +# be used. +# +# Example: google_key_path = /files/service-account-json +# +# Variable: AIRFLOW__API__GOOGLE_KEY_PATH +# +google_key_path = + +# Used in response to a preflight request to indicate which HTTP +# headers can be used when making the actual request. This header is +# the server side response to the browser's +# Access-Control-Request-Headers header. +# +# Variable: AIRFLOW__API__ACCESS_CONTROL_ALLOW_HEADERS +# +access_control_allow_headers = + +# Specifies the method or methods allowed when accessing the resource. +# +# Variable: AIRFLOW__API__ACCESS_CONTROL_ALLOW_METHODS +# +access_control_allow_methods = + +# Indicates whether the response can be shared with requesting code from the given origins. +# Separate URLs with space. +# +# Variable: AIRFLOW__API__ACCESS_CONTROL_ALLOW_ORIGINS +# +access_control_allow_origins = + +# Indicates whether the **xcomEntries** endpoint supports the **deserialize** +# flag. If set to ``False``, setting this flag in a request would result in a +# 400 Bad Request error. +# +# Variable: AIRFLOW__API__ENABLE_XCOM_DESERIALIZE_SUPPORT +# +enable_xcom_deserialize_support = False + +[lineage] +# what lineage backend to use +# +# Variable: AIRFLOW__LINEAGE__BACKEND +# +backend = + +[operators] +# The default owner assigned to each new operator, unless +# provided explicitly or passed via ``default_args`` +# +# Variable: AIRFLOW__OPERATORS__DEFAULT_OWNER +# +default_owner = airflow + +# The default value of attribute "deferrable" in operators and sensors. +# +# Variable: AIRFLOW__OPERATORS__DEFAULT_DEFERRABLE +# +default_deferrable = false + +# Indicates the default number of CPU units allocated to each operator when no specific CPU request +# is specified in the operator's configuration +# +# Variable: AIRFLOW__OPERATORS__DEFAULT_CPUS +# +default_cpus = 1 + +# Indicates the default number of RAM allocated to each operator when no specific RAM request +# is specified in the operator's configuration +# +# Variable: AIRFLOW__OPERATORS__DEFAULT_RAM +# +default_ram = 512 + +# Indicates the default number of disk storage allocated to each operator when no specific disk request +# is specified in the operator's configuration +# +# Variable: AIRFLOW__OPERATORS__DEFAULT_DISK +# +default_disk = 512 + +# Indicates the default number of GPUs allocated to each operator when no specific GPUs request +# is specified in the operator's configuration +# +# Variable: AIRFLOW__OPERATORS__DEFAULT_GPUS +# +default_gpus = 0 + +# Default queue that tasks get assigned to and that worker listen on. +# +# Variable: AIRFLOW__OPERATORS__DEFAULT_QUEUE +# +default_queue = default + +# Is allowed to pass additional/unused arguments (args, kwargs) to the BaseOperator operator. +# If set to ``False``, an exception will be thrown, +# otherwise only the console message will be displayed. +# +# Variable: AIRFLOW__OPERATORS__ALLOW_ILLEGAL_ARGUMENTS +# +allow_illegal_arguments = False + +[webserver] +# The message displayed when a user attempts to execute actions beyond their authorised privileges. +# +# Variable: AIRFLOW__WEBSERVER__ACCESS_DENIED_MESSAGE +# +access_denied_message = Access is Denied + +# Path of webserver config file used for configuring the webserver parameters +# +# Variable: AIRFLOW__WEBSERVER__CONFIG_FILE +# +config_file = /Users/palaeosaurus/Data-Projects/2024/sensors-and-more/webserver_config.py + +# The base url of your website: Airflow cannot guess what domain or CNAME you are using. +# This is used to create links in the Log Url column in the Browse - Task Instances menu, +# as well as in any automated emails sent by Airflow that contain links to your webserver. +# +# Variable: AIRFLOW__WEBSERVER__BASE_URL +# +base_url = http://localhost:8080 + +# Default timezone to display all dates in the UI, can be UTC, system, or +# any IANA timezone string (e.g. **Europe/Amsterdam**). If left empty the +# default value of core/default_timezone will be used +# +# Example: default_ui_timezone = America/New_York +# +# Variable: AIRFLOW__WEBSERVER__DEFAULT_UI_TIMEZONE +# +default_ui_timezone = UTC + +# The ip specified when starting the web server +# +# Variable: AIRFLOW__WEBSERVER__WEB_SERVER_HOST +# +web_server_host = 0.0.0.0 + +# The port on which to run the web server +# +# Variable: AIRFLOW__WEBSERVER__WEB_SERVER_PORT +# +web_server_port = 8080 + +# Paths to the SSL certificate and key for the web server. When both are +# provided SSL will be enabled. This does not change the web server port. +# +# Variable: AIRFLOW__WEBSERVER__WEB_SERVER_SSL_CERT +# +web_server_ssl_cert = + +# Paths to the SSL certificate and key for the web server. When both are +# provided SSL will be enabled. This does not change the web server port. +# +# Variable: AIRFLOW__WEBSERVER__WEB_SERVER_SSL_KEY +# +web_server_ssl_key = + +# The type of backend used to store web session data, can be ``database`` or ``securecookie``. For the +# ``database`` backend, sessions are store in the database and they can be +# managed there (for example when you reset password of the user, all sessions for that user are +# deleted). For the ``securecookie`` backend, sessions are stored in encrypted cookies on the client +# side. The ``securecookie`` mechanism is 'lighter' than database backend, but sessions are not deleted +# when you reset password of the user, which means that other than waiting for expiry time, the only +# way to invalidate all sessions for a user is to change secret_key and restart webserver (which +# also invalidates and logs out all other user's sessions). +# +# When you are using ``database`` backend, make sure to keep your database session table small +# by periodically running ``airflow db clean --table session`` command, especially if you have +# automated API calls that will create a new session for each call rather than reuse the sessions +# stored in browser cookies. +# +# Example: session_backend = securecookie +# +# Variable: AIRFLOW__WEBSERVER__SESSION_BACKEND +# +session_backend = database + +# Number of seconds the webserver waits before killing gunicorn master that doesn't respond +# +# Variable: AIRFLOW__WEBSERVER__WEB_SERVER_MASTER_TIMEOUT +# +web_server_master_timeout = 120 + +# Number of seconds the gunicorn webserver waits before timing out on a worker +# +# Variable: AIRFLOW__WEBSERVER__WEB_SERVER_WORKER_TIMEOUT +# +web_server_worker_timeout = 120 + +# Number of workers to refresh at a time. When set to 0, worker refresh is +# disabled. When nonzero, airflow periodically refreshes webserver workers by +# bringing up new ones and killing old ones. +# +# Variable: AIRFLOW__WEBSERVER__WORKER_REFRESH_BATCH_SIZE +# +worker_refresh_batch_size = 1 + +# Number of seconds to wait before refreshing a batch of workers. +# +# Variable: AIRFLOW__WEBSERVER__WORKER_REFRESH_INTERVAL +# +worker_refresh_interval = 6000 + +# If set to ``True``, Airflow will track files in plugins_folder directory. When it detects changes, +# then reload the gunicorn. If set to ``True``, gunicorn starts without preloading, which is slower, +# uses more memory, and may cause race conditions. Avoid setting this to ``True`` in production. +# +# Variable: AIRFLOW__WEBSERVER__RELOAD_ON_PLUGIN_CHANGE +# +reload_on_plugin_change = False + +# Secret key used to run your flask app. It should be as random as possible. However, when running +# more than 1 instances of webserver, make sure all of them use the same ``secret_key`` otherwise +# one of them will error with "CSRF session token is missing". +# The webserver key is also used to authorize requests to Celery workers when logs are retrieved. +# The token generated using the secret key has a short expiry time though - make sure that time on +# ALL the machines that you run airflow components on is synchronized (for example using ntpd) +# otherwise you might get "forbidden" errors when the logs are accessed. +# +# Variable: AIRFLOW__WEBSERVER__SECRET_KEY +# +secret_key = V+NLBH8nX8SVAGEbyv28HQ== + +# Number of workers to run the Gunicorn web server +# +# Variable: AIRFLOW__WEBSERVER__WORKERS +# +workers = 4 + +# The worker class gunicorn should use. Choices include +# ``sync`` (default), ``eventlet``, ``gevent``. +# +# .. warning:: +# +# When using ``gevent`` you might also want to set the ``_AIRFLOW_PATCH_GEVENT`` +# environment variable to ``"1"`` to make sure gevent patching is done as early as possible. +# +# See related Issues / PRs for more details: +# +# * https://github.com/benoitc/gunicorn/issues/2796 +# * https://github.com/apache/airflow/issues/8212 +# * https://github.com/apache/airflow/pull/28283 +# +# Variable: AIRFLOW__WEBSERVER__WORKER_CLASS +# +worker_class = sync + +# Log files for the gunicorn webserver. '-' means log to stderr. +# +# Variable: AIRFLOW__WEBSERVER__ACCESS_LOGFILE +# +access_logfile = - + +# Log files for the gunicorn webserver. '-' means log to stderr. +# +# Variable: AIRFLOW__WEBSERVER__ERROR_LOGFILE +# +error_logfile = - + +# Access log format for gunicorn webserver. +# default format is ``%%(h)s %%(l)s %%(u)s %%(t)s "%%(r)s" %%(s)s %%(b)s "%%(f)s" "%%(a)s"`` +# See `Gunicorn Settings: 'access_log_format' Reference +# `__ for more details +# +# Variable: AIRFLOW__WEBSERVER__ACCESS_LOGFORMAT +# +access_logformat = + +# Expose the configuration file in the web server. Set to ``non-sensitive-only`` to show all values +# except those that have security implications. ``True`` shows all values. ``False`` hides the +# configuration completely. +# +# Variable: AIRFLOW__WEBSERVER__EXPOSE_CONFIG +# +expose_config = False + +# Expose hostname in the web server +# +# Variable: AIRFLOW__WEBSERVER__EXPOSE_HOSTNAME +# +expose_hostname = False + +# Expose stacktrace in the web server +# +# Variable: AIRFLOW__WEBSERVER__EXPOSE_STACKTRACE +# +expose_stacktrace = False + +# Default DAG view. Valid values are: ``grid``, ``graph``, ``duration``, ``gantt``, ``landing_times`` +# +# Variable: AIRFLOW__WEBSERVER__DAG_DEFAULT_VIEW +# +dag_default_view = grid + +# Default DAG orientation. Valid values are: +# ``LR`` (Left->Right), ``TB`` (Top->Bottom), ``RL`` (Right->Left), ``BT`` (Bottom->Top) +# +# Variable: AIRFLOW__WEBSERVER__DAG_ORIENTATION +# +dag_orientation = LR + +# Sorting order in grid view. Valid values are: ``topological``, ``hierarchical_alphabetical`` +# +# Variable: AIRFLOW__WEBSERVER__GRID_VIEW_SORTING_ORDER +# +grid_view_sorting_order = topological + +# The amount of time (in secs) webserver will wait for initial handshake +# while fetching logs from other worker machine +# +# Variable: AIRFLOW__WEBSERVER__LOG_FETCH_TIMEOUT_SEC +# +log_fetch_timeout_sec = 5 + +# Time interval (in secs) to wait before next log fetching. +# +# Variable: AIRFLOW__WEBSERVER__LOG_FETCH_DELAY_SEC +# +log_fetch_delay_sec = 2 + +# Distance away from page bottom to enable auto tailing. +# +# Variable: AIRFLOW__WEBSERVER__LOG_AUTO_TAILING_OFFSET +# +log_auto_tailing_offset = 30 + +# Animation speed for auto tailing log display. +# +# Variable: AIRFLOW__WEBSERVER__LOG_ANIMATION_SPEED +# +log_animation_speed = 1000 + +# By default, the webserver shows paused DAGs. Flip this to hide paused +# DAGs by default +# +# Variable: AIRFLOW__WEBSERVER__HIDE_PAUSED_DAGS_BY_DEFAULT +# +hide_paused_dags_by_default = False + +# Consistent page size across all listing views in the UI +# +# Variable: AIRFLOW__WEBSERVER__PAGE_SIZE +# +page_size = 100 + +# Define the color of navigation bar +# +# Variable: AIRFLOW__WEBSERVER__NAVBAR_COLOR +# +navbar_color = #fff + +# Define the color of text in the navigation bar +# +# Variable: AIRFLOW__WEBSERVER__NAVBAR_TEXT_COLOR +# +navbar_text_color = #51504f + +# Define the color of navigation bar links when hovered +# +# Variable: AIRFLOW__WEBSERVER__NAVBAR_HOVER_COLOR +# +navbar_hover_color = #eee + +# Define the color of text in the navigation bar when hovered +# +# Variable: AIRFLOW__WEBSERVER__NAVBAR_TEXT_HOVER_COLOR +# +navbar_text_hover_color = #51504f + +# Define the color of the logo text +# +# Variable: AIRFLOW__WEBSERVER__NAVBAR_LOGO_TEXT_COLOR +# +navbar_logo_text_color = #51504f + +# Default dagrun to show in UI +# +# Variable: AIRFLOW__WEBSERVER__DEFAULT_DAG_RUN_DISPLAY_NUMBER +# +default_dag_run_display_number = 25 + +# Enable werkzeug ``ProxyFix`` middleware for reverse proxy +# +# Variable: AIRFLOW__WEBSERVER__ENABLE_PROXY_FIX +# +enable_proxy_fix = False + +# Number of values to trust for ``X-Forwarded-For``. +# See `Werkzeug: X-Forwarded-For Proxy Fix +# `__ for more details. +# +# Variable: AIRFLOW__WEBSERVER__PROXY_FIX_X_FOR +# +proxy_fix_x_for = 1 + +# Number of values to trust for ``X-Forwarded-Proto``. +# See `Werkzeug: X-Forwarded-For Proxy Fix +# `__ for more details. +# +# Variable: AIRFLOW__WEBSERVER__PROXY_FIX_X_PROTO +# +proxy_fix_x_proto = 1 + +# Number of values to trust for ``X-Forwarded-Host``. +# See `Werkzeug: X-Forwarded-For Proxy Fix +# `__ for more details. +# +# Variable: AIRFLOW__WEBSERVER__PROXY_FIX_X_HOST +# +proxy_fix_x_host = 1 + +# Number of values to trust for ``X-Forwarded-Port``. +# See `Werkzeug: X-Forwarded-For Proxy Fix +# `__ for more details. +# +# Variable: AIRFLOW__WEBSERVER__PROXY_FIX_X_PORT +# +proxy_fix_x_port = 1 + +# Number of values to trust for ``X-Forwarded-Prefix``. +# See `Werkzeug: X-Forwarded-For Proxy Fix +# `__ for more details. +# +# Variable: AIRFLOW__WEBSERVER__PROXY_FIX_X_PREFIX +# +proxy_fix_x_prefix = 1 + +# Set secure flag on session cookie +# +# Variable: AIRFLOW__WEBSERVER__COOKIE_SECURE +# +cookie_secure = False + +# Set samesite policy on session cookie +# +# Variable: AIRFLOW__WEBSERVER__COOKIE_SAMESITE +# +cookie_samesite = Lax + +# Default setting for wrap toggle on DAG code and TI log views. +# +# Variable: AIRFLOW__WEBSERVER__DEFAULT_WRAP +# +default_wrap = False + +# Allow the UI to be rendered in a frame +# +# Variable: AIRFLOW__WEBSERVER__X_FRAME_ENABLED +# +x_frame_enabled = True + +# Send anonymous user activity to your analytics tool +# choose from ``google_analytics``, ``segment``, ``metarouter``, or ``matomo`` +# +# Variable: AIRFLOW__WEBSERVER__ANALYTICS_TOOL +# +# analytics_tool = + +# Unique ID of your account in the analytics tool +# +# Variable: AIRFLOW__WEBSERVER__ANALYTICS_ID +# +# analytics_id = + +# Your instances url, only applicable to Matomo. +# +# Example: analytics_url = https://your.matomo.instance.com/ +# +# Variable: AIRFLOW__WEBSERVER__ANALYTICS_URL +# +# analytics_url = + +# 'Recent Tasks' stats will show for old DagRuns if set +# +# Variable: AIRFLOW__WEBSERVER__SHOW_RECENT_STATS_FOR_COMPLETED_RUNS +# +show_recent_stats_for_completed_runs = True + +# The UI cookie lifetime in minutes. User will be logged out from UI after +# ``[webserver] session_lifetime_minutes`` of non-activity +# +# Variable: AIRFLOW__WEBSERVER__SESSION_LIFETIME_MINUTES +# +session_lifetime_minutes = 43200 + +# Sets a custom page title for the DAGs overview page and site title for all pages +# +# Variable: AIRFLOW__WEBSERVER__INSTANCE_NAME +# +# instance_name = + +# Whether the custom page title for the DAGs overview page contains any Markup language +# +# Variable: AIRFLOW__WEBSERVER__INSTANCE_NAME_HAS_MARKUP +# +instance_name_has_markup = False + +# How frequently, in seconds, the DAG data will auto-refresh in graph or grid view +# when auto-refresh is turned on +# +# Variable: AIRFLOW__WEBSERVER__AUTO_REFRESH_INTERVAL +# +auto_refresh_interval = 3 + +# Boolean for displaying warning for publicly viewable deployment +# +# Variable: AIRFLOW__WEBSERVER__WARN_DEPLOYMENT_EXPOSURE +# +warn_deployment_exposure = True + +# Comma separated string of view events to exclude from dag audit view. +# All other events will be added minus the ones passed here. +# The audit logs in the db will not be affected by this parameter. +# +# Example: audit_view_excluded_events = cli_task_run,running,success +# +# Variable: AIRFLOW__WEBSERVER__AUDIT_VIEW_EXCLUDED_EVENTS +# +# audit_view_excluded_events = + +# Comma separated string of view events to include in dag audit view. +# If passed, only these events will populate the dag audit view. +# The audit logs in the db will not be affected by this parameter. +# +# Example: audit_view_included_events = dagrun_cleared,failed +# +# Variable: AIRFLOW__WEBSERVER__AUDIT_VIEW_INCLUDED_EVENTS +# +# audit_view_included_events = + +# Boolean for running SwaggerUI in the webserver. +# +# Variable: AIRFLOW__WEBSERVER__ENABLE_SWAGGER_UI +# +enable_swagger_ui = True + +# Boolean for running Internal API in the webserver. +# +# Variable: AIRFLOW__WEBSERVER__RUN_INTERNAL_API +# +run_internal_api = False + +# The caching algorithm used by the webserver. Must be a valid hashlib function name. +# +# Example: caching_hash_method = sha256 +# +# Variable: AIRFLOW__WEBSERVER__CACHING_HASH_METHOD +# +caching_hash_method = md5 + +# Behavior of the trigger DAG run button for DAGs without params. ``False`` to skip and trigger +# without displaying a form to add a **dag_run.conf**, ``True`` to always display the form. +# The form is displayed always if parameters are defined. +# +# Variable: AIRFLOW__WEBSERVER__SHOW_TRIGGER_FORM_IF_NO_PARAMS +# +show_trigger_form_if_no_params = False + +# Number of recent DAG run configurations in the selector on the trigger web form. +# +# Example: num_recent_configurations_for_trigger = 10 +# +# Variable: AIRFLOW__WEBSERVER__NUM_RECENT_CONFIGURATIONS_FOR_TRIGGER +# +num_recent_configurations_for_trigger = 5 + +# A DAG author is able to provide any raw HTML into ``doc_md`` or params description in +# ``description_md`` for text formatting. This is including potentially unsafe javascript. +# Displaying the DAG or trigger form in web UI provides the DAG author the potential to +# inject malicious code into clients browsers. To ensure the web UI is safe by default, +# raw HTML is disabled by default. If you trust your DAG authors, you can enable HTML +# support in markdown by setting this option to ``True``. +# +# This parameter also enables the deprecated fields ``description_html`` and +# ``custom_html_form`` in DAG params until the feature is removed in a future version. +# +# Example: allow_raw_html_descriptions = False +# +# Variable: AIRFLOW__WEBSERVER__ALLOW_RAW_HTML_DESCRIPTIONS +# +allow_raw_html_descriptions = False + +# The maximum size of the request payload (in MB) that can be sent. +# +# Variable: AIRFLOW__WEBSERVER__ALLOWED_PAYLOAD_SIZE +# +allowed_payload_size = 1.0 + +# Require confirmation when changing a DAG in the web UI. This is to prevent accidental changes +# to a DAG that may be running on sensitive environments like production. +# When set to ``True``, confirmation dialog will be shown when a user tries to Pause/Unpause, +# Trigger a DAG +# +# Variable: AIRFLOW__WEBSERVER__REQUIRE_CONFIRMATION_DAG_CHANGE +# +require_confirmation_dag_change = False + +[email] +# Configuration email backend and whether to +# send email alerts on retry or failure + +# Email backend to use +# +# Variable: AIRFLOW__EMAIL__EMAIL_BACKEND +# +email_backend = airflow.utils.email.send_email_smtp + +# Email connection to use +# +# Variable: AIRFLOW__EMAIL__EMAIL_CONN_ID +# +email_conn_id = smtp_default + +# Whether email alerts should be sent when a task is retried +# +# Variable: AIRFLOW__EMAIL__DEFAULT_EMAIL_ON_RETRY +# +default_email_on_retry = True + +# Whether email alerts should be sent when a task failed +# +# Variable: AIRFLOW__EMAIL__DEFAULT_EMAIL_ON_FAILURE +# +default_email_on_failure = True + +# File that will be used as the template for Email subject (which will be rendered using Jinja2). +# If not set, Airflow uses a base template. +# +# Example: subject_template = /path/to/my_subject_template_file +# +# Variable: AIRFLOW__EMAIL__SUBJECT_TEMPLATE +# +# subject_template = + +# File that will be used as the template for Email content (which will be rendered using Jinja2). +# If not set, Airflow uses a base template. +# +# Example: html_content_template = /path/to/my_html_content_template_file +# +# Variable: AIRFLOW__EMAIL__HTML_CONTENT_TEMPLATE +# +# html_content_template = + +# Email address that will be used as sender address. +# It can either be raw email or the complete address in a format ``Sender Name `` +# +# Example: from_email = Airflow +# +# Variable: AIRFLOW__EMAIL__FROM_EMAIL +# +# from_email = + +# ssl context to use when using SMTP and IMAP SSL connections. By default, the context is "default" +# which sets it to ``ssl.create_default_context()`` which provides the right balance between +# compatibility and security, it however requires that certificates in your operating system are +# updated and that SMTP/IMAP servers of yours have valid certificates that have corresponding public +# keys installed on your machines. You can switch it to "none" if you want to disable checking +# of the certificates, but it is not recommended as it allows MITM (man-in-the-middle) attacks +# if your infrastructure is not sufficiently secured. It should only be set temporarily while you +# are fixing your certificate configuration. This can be typically done by upgrading to newer +# version of the operating system you run Airflow components on,by upgrading/refreshing proper +# certificates in the OS or by updating certificates for your mail servers. +# +# Example: ssl_context = default +# +# Variable: AIRFLOW__EMAIL__SSL_CONTEXT +# +ssl_context = default + +[smtp] +# If you want airflow to send emails on retries, failure, and you want to use +# the airflow.utils.email.send_email_smtp function, you have to configure an +# smtp server here + +# Specifies the host server address used by Airflow when sending out email notifications via SMTP. +# +# Variable: AIRFLOW__SMTP__SMTP_HOST +# +smtp_host = localhost + +# Determines whether to use the STARTTLS command when connecting to the SMTP server. +# +# Variable: AIRFLOW__SMTP__SMTP_STARTTLS +# +smtp_starttls = True + +# Determines whether to use an SSL connection when talking to the SMTP server. +# +# Variable: AIRFLOW__SMTP__SMTP_SSL +# +smtp_ssl = False + +# Username to authenticate when connecting to smtp server. +# +# Example: smtp_user = airflow +# +# Variable: AIRFLOW__SMTP__SMTP_USER +# +# smtp_user = + +# Password to authenticate when connecting to smtp server. +# +# Example: smtp_password = airflow +# +# Variable: AIRFLOW__SMTP__SMTP_PASSWORD +# +# smtp_password = + +# Defines the port number on which Airflow connects to the SMTP server to send email notifications. +# +# Variable: AIRFLOW__SMTP__SMTP_PORT +# +smtp_port = 25 + +# Specifies the default **from** email address used when Airflow sends email notifications. +# +# Variable: AIRFLOW__SMTP__SMTP_MAIL_FROM +# +smtp_mail_from = airflow@example.com + +# Determines the maximum time (in seconds) the Apache Airflow system will wait for a +# connection to the SMTP server to be established. +# +# Variable: AIRFLOW__SMTP__SMTP_TIMEOUT +# +smtp_timeout = 30 + +# Defines the maximum number of times Airflow will attempt to connect to the SMTP server. +# +# Variable: AIRFLOW__SMTP__SMTP_RETRY_LIMIT +# +smtp_retry_limit = 5 + +[sentry] +# `Sentry `__ integration. Here you can supply +# additional configuration options based on the Python platform. +# See `Python / Configuration / Basic Options +# `__ for more details. +# Unsupported options: ``integrations``, ``in_app_include``, ``in_app_exclude``, +# ``ignore_errors``, ``before_breadcrumb``, ``transport``. + +# Enable error reporting to Sentry +# +# Variable: AIRFLOW__SENTRY__SENTRY_ON +# +sentry_on = false + +# +# Variable: AIRFLOW__SENTRY__SENTRY_DSN +# +sentry_dsn = + +# Dotted path to a before_send function that the sentry SDK should be configured to use. +# +# Variable: AIRFLOW__SENTRY__BEFORE_SEND +# +# before_send = + +[scheduler] +# Task instances listen for external kill signal (when you clear tasks +# from the CLI or the UI), this defines the frequency at which they should +# listen (in seconds). +# +# Variable: AIRFLOW__SCHEDULER__JOB_HEARTBEAT_SEC +# +job_heartbeat_sec = 5 + +# The scheduler constantly tries to trigger new tasks (look at the +# scheduler section in the docs for more information). This defines +# how often the scheduler should run (in seconds). +# +# Variable: AIRFLOW__SCHEDULER__SCHEDULER_HEARTBEAT_SEC +# +scheduler_heartbeat_sec = 5 + +# The frequency (in seconds) at which the LocalTaskJob should send heartbeat signals to the +# scheduler to notify it's still alive. If this value is set to 0, the heartbeat interval will default +# to the value of ``[scheduler] scheduler_zombie_task_threshold``. +# +# Variable: AIRFLOW__SCHEDULER__LOCAL_TASK_JOB_HEARTBEAT_SEC +# +local_task_job_heartbeat_sec = 0 + +# The number of times to try to schedule each DAG file +# -1 indicates unlimited number +# +# Variable: AIRFLOW__SCHEDULER__NUM_RUNS +# +num_runs = -1 + +# Controls how long the scheduler will sleep between loops, but if there was nothing to do +# in the loop. i.e. if it scheduled something then it will start the next loop +# iteration straight away. +# +# Variable: AIRFLOW__SCHEDULER__SCHEDULER_IDLE_SLEEP_TIME +# +scheduler_idle_sleep_time = 1 + +# Number of seconds after which a DAG file is parsed. The DAG file is parsed every +# ``[scheduler] min_file_process_interval`` number of seconds. Updates to DAGs are reflected after +# this interval. Keeping this number low will increase CPU usage. +# +# Variable: AIRFLOW__SCHEDULER__MIN_FILE_PROCESS_INTERVAL +# +min_file_process_interval = 30 + +# How often (in seconds) to check for stale DAGs (DAGs which are no longer present in +# the expected files) which should be deactivated, as well as datasets that are no longer +# referenced and should be marked as orphaned. +# +# Variable: AIRFLOW__SCHEDULER__PARSING_CLEANUP_INTERVAL +# +parsing_cleanup_interval = 60 + +# How long (in seconds) to wait after we have re-parsed a DAG file before deactivating stale +# DAGs (DAGs which are no longer present in the expected files). The reason why we need +# this threshold is to account for the time between when the file is parsed and when the +# DAG is loaded. The absolute maximum that this could take is ``[core] dag_file_processor_timeout``, +# but when you have a long timeout configured, it results in a significant delay in the +# deactivation of stale dags. +# +# Variable: AIRFLOW__SCHEDULER__STALE_DAG_THRESHOLD +# +stale_dag_threshold = 50 + +# How often (in seconds) to scan the DAGs directory for new files. Default to 5 minutes. +# +# Variable: AIRFLOW__SCHEDULER__DAG_DIR_LIST_INTERVAL +# +dag_dir_list_interval = 300 + +# How often should stats be printed to the logs. Setting to 0 will disable printing stats +# +# Variable: AIRFLOW__SCHEDULER__PRINT_STATS_INTERVAL +# +print_stats_interval = 30 + +# How often (in seconds) should pool usage stats be sent to StatsD (if statsd_on is enabled) +# +# Variable: AIRFLOW__SCHEDULER__POOL_METRICS_INTERVAL +# +pool_metrics_interval = 5.0 + +# If the last scheduler heartbeat happened more than ``[scheduler] scheduler_health_check_threshold`` +# ago (in seconds), scheduler is considered unhealthy. +# This is used by the health check in the **/health** endpoint and in ``airflow jobs check`` CLI +# for SchedulerJob. +# +# Variable: AIRFLOW__SCHEDULER__SCHEDULER_HEALTH_CHECK_THRESHOLD +# +scheduler_health_check_threshold = 30 + +# When you start a scheduler, airflow starts a tiny web server +# subprocess to serve a health check if this is set to ``True`` +# +# Variable: AIRFLOW__SCHEDULER__ENABLE_HEALTH_CHECK +# +enable_health_check = False + +# When you start a scheduler, airflow starts a tiny web server +# subprocess to serve a health check on this host +# +# Variable: AIRFLOW__SCHEDULER__SCHEDULER_HEALTH_CHECK_SERVER_HOST +# +scheduler_health_check_server_host = 0.0.0.0 + +# When you start a scheduler, airflow starts a tiny web server +# subprocess to serve a health check on this port +# +# Variable: AIRFLOW__SCHEDULER__SCHEDULER_HEALTH_CHECK_SERVER_PORT +# +scheduler_health_check_server_port = 8974 + +# How often (in seconds) should the scheduler check for orphaned tasks and SchedulerJobs +# +# Variable: AIRFLOW__SCHEDULER__ORPHANED_TASKS_CHECK_INTERVAL +# +orphaned_tasks_check_interval = 300.0 + +# Determines the directory where logs for the child processes of the scheduler will be stored +# +# Variable: AIRFLOW__SCHEDULER__CHILD_PROCESS_LOG_DIRECTORY +# +child_process_log_directory = /Users/palaeosaurus/Data-Projects/2024/sensors-and-more/logs/scheduler + +# Local task jobs periodically heartbeat to the DB. If the job has +# not heartbeat in this many seconds, the scheduler will mark the +# associated task instance as failed and will re-schedule the task. +# +# Variable: AIRFLOW__SCHEDULER__SCHEDULER_ZOMBIE_TASK_THRESHOLD +# +scheduler_zombie_task_threshold = 300 + +# How often (in seconds) should the scheduler check for zombie tasks. +# +# Variable: AIRFLOW__SCHEDULER__ZOMBIE_DETECTION_INTERVAL +# +zombie_detection_interval = 10.0 + +# Turn off scheduler catchup by setting this to ``False``. +# Default behavior is unchanged and +# Command Line Backfills still work, but the scheduler +# will not do scheduler catchup if this is ``False``, +# however it can be set on a per DAG basis in the +# DAG definition (catchup) +# +# Variable: AIRFLOW__SCHEDULER__CATCHUP_BY_DEFAULT +# +catchup_by_default = True + +# Setting this to ``True`` will make first task instance of a task +# ignore depends_on_past setting. A task instance will be considered +# as the first task instance of a task when there is no task instance +# in the DB with an execution_date earlier than it., i.e. no manual marking +# success will be needed for a newly added task to be scheduled. +# +# Variable: AIRFLOW__SCHEDULER__IGNORE_FIRST_DEPENDS_ON_PAST_BY_DEFAULT +# +ignore_first_depends_on_past_by_default = True + +# This changes the batch size of queries in the scheduling main loop. +# This should not be greater than ``[core] parallelism``. +# If this is too high, SQL query performance may be impacted by +# complexity of query predicate, and/or excessive locking. +# Additionally, you may hit the maximum allowable query length for your db. +# Set this to 0 to use the value of ``[core] parallelism`` +# +# Variable: AIRFLOW__SCHEDULER__MAX_TIS_PER_QUERY +# +max_tis_per_query = 16 + +# Should the scheduler issue ``SELECT ... FOR UPDATE`` in relevant queries. +# If this is set to ``False`` then you should not run more than a single +# scheduler at once +# +# Variable: AIRFLOW__SCHEDULER__USE_ROW_LEVEL_LOCKING +# +use_row_level_locking = True + +# Max number of DAGs to create DagRuns for per scheduler loop. +# +# Variable: AIRFLOW__SCHEDULER__MAX_DAGRUNS_TO_CREATE_PER_LOOP +# +max_dagruns_to_create_per_loop = 10 + +# How many DagRuns should a scheduler examine (and lock) when scheduling +# and queuing tasks. +# +# Variable: AIRFLOW__SCHEDULER__MAX_DAGRUNS_PER_LOOP_TO_SCHEDULE +# +max_dagruns_per_loop_to_schedule = 20 + +# Should the Task supervisor process perform a "mini scheduler" to attempt to schedule more tasks of the +# same DAG. Leaving this on will mean tasks in the same DAG execute quicker, but might starve out other +# dags in some circumstances +# +# Variable: AIRFLOW__SCHEDULER__SCHEDULE_AFTER_TASK_EXECUTION +# +schedule_after_task_execution = True + +# The scheduler reads dag files to extract the airflow modules that are going to be used, +# and imports them ahead of time to avoid having to re-do it for each parsing process. +# This flag can be set to ``False`` to disable this behavior in case an airflow module needs +# to be freshly imported each time (at the cost of increased DAG parsing time). +# +# Variable: AIRFLOW__SCHEDULER__PARSING_PRE_IMPORT_MODULES +# +parsing_pre_import_modules = True + +# The scheduler can run multiple processes in parallel to parse dags. +# This defines how many processes will run. +# +# Variable: AIRFLOW__SCHEDULER__PARSING_PROCESSES +# +parsing_processes = 2 + +# One of ``modified_time``, ``random_seeded_by_host`` and ``alphabetical``. +# The scheduler will list and sort the dag files to decide the parsing order. +# +# * ``modified_time``: Sort by modified time of the files. This is useful on large scale to parse the +# recently modified DAGs first. +# * ``random_seeded_by_host``: Sort randomly across multiple Schedulers but with same order on the +# same host. This is useful when running with Scheduler in HA mode where each scheduler can +# parse different DAG files. +# * ``alphabetical``: Sort by filename +# +# Variable: AIRFLOW__SCHEDULER__FILE_PARSING_SORT_MODE +# +file_parsing_sort_mode = modified_time + +# Whether the dag processor is running as a standalone process or it is a subprocess of a scheduler +# job. +# +# Variable: AIRFLOW__SCHEDULER__STANDALONE_DAG_PROCESSOR +# +standalone_dag_processor = False + +# Only applicable if ``[scheduler] standalone_dag_processor`` is true and callbacks are stored +# in database. Contains maximum number of callbacks that are fetched during a single loop. +# +# Variable: AIRFLOW__SCHEDULER__MAX_CALLBACKS_PER_LOOP +# +max_callbacks_per_loop = 20 + +# Only applicable if ``[scheduler] standalone_dag_processor`` is true. +# Time in seconds after which dags, which were not updated by Dag Processor are deactivated. +# +# Variable: AIRFLOW__SCHEDULER__DAG_STALE_NOT_SEEN_DURATION +# +dag_stale_not_seen_duration = 600 + +# Turn off scheduler use of cron intervals by setting this to ``False``. +# DAGs submitted manually in the web UI or with trigger_dag will still run. +# +# Variable: AIRFLOW__SCHEDULER__USE_JOB_SCHEDULE +# +use_job_schedule = True + +# Allow externally triggered DagRuns for Execution Dates in the future +# Only has effect if schedule_interval is set to None in DAG +# +# Variable: AIRFLOW__SCHEDULER__ALLOW_TRIGGER_IN_FUTURE +# +allow_trigger_in_future = False + +# How often to check for expired trigger requests that have not run yet. +# +# Variable: AIRFLOW__SCHEDULER__TRIGGER_TIMEOUT_CHECK_INTERVAL +# +trigger_timeout_check_interval = 15 + +# Amount of time a task can be in the queued state before being retried or set to failed. +# +# Variable: AIRFLOW__SCHEDULER__TASK_QUEUED_TIMEOUT +# +task_queued_timeout = 600.0 + +# How often to check for tasks that have been in the queued state for +# longer than ``[scheduler] task_queued_timeout``. +# +# Variable: AIRFLOW__SCHEDULER__TASK_QUEUED_TIMEOUT_CHECK_INTERVAL +# +task_queued_timeout_check_interval = 120.0 + +# The run_id pattern used to verify the validity of user input to the run_id parameter when +# triggering a DAG. This pattern cannot change the pattern used by scheduler to generate run_id +# for scheduled DAG runs or DAG runs triggered without changing the run_id parameter. +# +# Variable: AIRFLOW__SCHEDULER__ALLOWED_RUN_ID_PATTERN +# +allowed_run_id_pattern = ^[A-Za-z0-9_.~:+-]+$ + +# Whether to create DAG runs that span an interval or one single point in time for cron schedules, when +# a cron string is provided to ``schedule`` argument of a DAG. +# +# * ``True``: **CronDataIntervalTimetable** is used, which is suitable +# for DAGs with well-defined data interval. You get contiguous intervals from the end of the previous +# interval up to the scheduled datetime. +# * ``False``: **CronTriggerTimetable** is used, which is closer to the behavior of cron itself. +# +# Notably, for **CronTriggerTimetable**, the logical date is the same as the time the DAG Run will +# try to schedule, while for **CronDataIntervalTimetable**, the logical date is the beginning of +# the data interval, but the DAG Run will try to schedule at the end of the data interval. +# +# Variable: AIRFLOW__SCHEDULER__CREATE_CRON_DATA_INTERVALS +# +create_cron_data_intervals = True + +[triggerer] +# How many triggers a single Triggerer will run at once, by default. +# +# Variable: AIRFLOW__TRIGGERER__DEFAULT_CAPACITY +# +default_capacity = 1000 + +# How often to heartbeat the Triggerer job to ensure it hasn't been killed. +# +# Variable: AIRFLOW__TRIGGERER__JOB_HEARTBEAT_SEC +# +job_heartbeat_sec = 5 + +# If the last triggerer heartbeat happened more than ``[triggerer] triggerer_health_check_threshold`` +# ago (in seconds), triggerer is considered unhealthy. +# This is used by the health check in the **/health** endpoint and in ``airflow jobs check`` CLI +# for TriggererJob. +# +# Variable: AIRFLOW__TRIGGERER__TRIGGERER_HEALTH_CHECK_THRESHOLD +# +triggerer_health_check_threshold = 30 + +[kerberos] +# Location of your ccache file once kinit has been performed. +# +# Variable: AIRFLOW__KERBEROS__CCACHE +# +ccache = /tmp/airflow_krb5_ccache + +# gets augmented with fqdn +# +# Variable: AIRFLOW__KERBEROS__PRINCIPAL +# +principal = airflow + +# Determines the frequency at which initialization or re-initialization processes occur. +# +# Variable: AIRFLOW__KERBEROS__REINIT_FREQUENCY +# +reinit_frequency = 3600 + +# Path to the kinit executable +# +# Variable: AIRFLOW__KERBEROS__KINIT_PATH +# +kinit_path = kinit + +# Designates the path to the Kerberos keytab file for the Airflow user +# +# Variable: AIRFLOW__KERBEROS__KEYTAB +# +keytab = airflow.keytab + +# Allow to disable ticket forwardability. +# +# Variable: AIRFLOW__KERBEROS__FORWARDABLE +# +forwardable = True + +# Allow to remove source IP from token, useful when using token behind NATted Docker host. +# +# Variable: AIRFLOW__KERBEROS__INCLUDE_IP +# +include_ip = True + +[sensors] +# Sensor default timeout, 7 days by default (7 * 24 * 60 * 60). +# +# Variable: AIRFLOW__SENSORS__DEFAULT_TIMEOUT +# +default_timeout = 604800 + +[common.io] +# Common IO configuration section + +# Path to a location on object storage where XComs can be stored in url format. +# +# Example: xcom_objectstorage_path = s3://conn_id@bucket/path +# +# Variable: AIRFLOW__COMMON.IO__XCOM_OBJECTSTORAGE_PATH +# +xcom_objectstorage_path = + +# Threshold in bytes for storing XComs in object storage. -1 means always store in the +# database. 0 means always store in object storage. Any positive number means +# it will be stored in object storage if the size of the value is greater than the threshold. +# +# Example: xcom_objectstorage_threshold = 1000000 +# +# Variable: AIRFLOW__COMMON.IO__XCOM_OBJECTSTORAGE_THRESHOLD +# +xcom_objectstorage_threshold = -1 + +# Compression algorithm to use when storing XComs in object storage. Supported algorithms +# are a.o.: snappy, zip, gzip, bz2, and lzma. If not specified, no compression will be used. +# Note that the compression algorithm must be available in the Python installation (e.g. +# python-snappy for snappy). Zip, gz, bz2 are available by default. +# +# Example: xcom_objectstorage_compression = gz +# +# Variable: AIRFLOW__COMMON.IO__XCOM_OBJECTSTORAGE_COMPRESSION +# +xcom_objectstorage_compression = + +[fab] +# This section contains configs specific to FAB provider. + +# Boolean for enabling rate limiting on authentication endpoints. +# +# Variable: AIRFLOW__FAB__AUTH_RATE_LIMITED +# +auth_rate_limited = True + +# Rate limit for authentication endpoints. +# +# Variable: AIRFLOW__FAB__AUTH_RATE_LIMIT +# +auth_rate_limit = 5 per 40 second + +# Update FAB permissions and sync security manager roles +# on webserver startup +# +# Variable: AIRFLOW__FAB__UPDATE_FAB_PERMS +# +update_fab_perms = True + +[imap] +# Options for IMAP provider. + +# ssl_context = + +[smtp_provider] +# Options for SMTP provider. + +# ssl context to use when using SMTP and IMAP SSL connections. By default, the context is "default" +# which sets it to ``ssl.create_default_context()`` which provides the right balance between +# compatibility and security, it however requires that certificates in your operating system are +# updated and that SMTP/IMAP servers of yours have valid certificates that have corresponding public +# keys installed on your machines. You can switch it to "none" if you want to disable checking +# of the certificates, but it is not recommended as it allows MITM (man-in-the-middle) attacks +# if your infrastructure is not sufficiently secured. It should only be set temporarily while you +# are fixing your certificate configuration. This can be typically done by upgrading to newer +# version of the operating system you run Airflow components on,by upgrading/refreshing proper +# certificates in the OS or by updating certificates for your mail servers. +# +# If you do not set this option explicitly, it will use Airflow "email.ssl_context" configuration, +# but if this configuration is not present, it will use "default" value. +# +# Example: ssl_context = default +# +# Variable: AIRFLOW__SMTP_PROVIDER__SSL_CONTEXT +# +# ssl_context = + +# Allows overriding of the standard templated email subject line when the SmtpNotifier is used. +# Must provide a path to the template. +# +# Example: templated_email_subject_path = path/to/override/email_subject.html +# +# Variable: AIRFLOW__SMTP_PROVIDER__TEMPLATED_EMAIL_SUBJECT_PATH +# +# templated_email_subject_path = + +# Allows overriding of the standard templated email path when the SmtpNotifier is used. Must provide +# a path to the template. +# +# Example: templated_html_content_path = path/to/override/email.html +# +# Variable: AIRFLOW__SMTP_PROVIDER__TEMPLATED_HTML_CONTENT_PATH +# +# templated_html_content_path = + diff --git a/airflow.db b/airflow.db new file mode 100644 index 0000000000000000000000000000000000000000..b7cd8d38b2d1a6f91e1587a66f439a19518f7b15 GIT binary patch literal 1130496 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 z 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.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�F>6>C&&!Fl~;oR3h_|pf}r~Ysd za(s6H9wW$+hRdg6CP7H!p0h6p;E`Gos7AprjaH5b#&_V^u}Pyi+S9ds0qUx24|Ce% zZ|sXt7xA%Bw*b^Q*;~NmWyi&0&ULD=8XI%(-IA>sNkdsRjW`O;ZJdPc(r56-P{Crd z=YIB=?*IAQU;b+@Y(y(G?+L(D#8#xy5Eh(+9j>_N?6(GBk;9{B!8O#_t@y6Z*@`L@ z*+7n_;tdY6WTtk-NCS;{gEP2FX1#NN`h!37!~f*({`En&;=2Oy7_}8KTn<|?o6ltS zeDrt_9yzE59iiDC$*{ii?(uI$LO>|e^h_F?qLA|#Qt*xaW~^ILbevZUnT%7nq^Bm;ISb}8>wbwFG2PKk6~K8!C@_zJNK2ZeEGW`{jv8AfY##!q7`tc zFp%eR#oV5cd^!lN98wimU6~lPuCE*)|4xm=Ayo9NVYr1R$02_+-kr*j0V+hE2kI==7dZydRE_|l=H2Y!D4FYo*O-pZcWcm2Jo%MUHHlYh*=Hs+KqAxkYY zql-`&uTeAuwGNj{(B3>cFutKTh_%e>=l|K4Bz^x{tpK$agGj4Ww1BVEiC3;FzG z&;Q>6WGUc5)&f0_EH|+kalU{zrd|{KI{lOdcJK&CzJMfz}IZ zLECfg?GQ8qQXS_Y-NWYASGeJMcD6@XV>LYc_Km8+Ujho3_fS@tvEK|vMCTojO2Lz7 z9pfS+@7hsw+;$DOmJos&&utKvC;VapkY)6&mi4M|92prEjOX0X{=47)k^lAgFAP9H z-xNSVuC3-@6dd}Ba1sRp{a7dt;V5ckzH}pOXN27heH4{^e3SNHfBK8HK?v`W0XHy))6+UUy>xZYxj^#(14u6-(ObOH{C!f8hTwI` z4IGI_HLV#LIEZ;RFu>N*IF04=xWoCt-}tqEdhRy|!Q*=a@ECDmpnEnX{Gtp?xcLgS z)S(4|nnhAD&jwy!d1MoGQyA$(ZyLxJtZBHC^&pK~iP@X+N>b6W0V9)BlG6SEF{DsC zRyz7mj(+m+|9I%!!GCbzx&41FI&?CFElwWP?bBAA`JPo+_pPhRD6JNOQ zgBnVtZopB?m#0C5?D#*(io}d&WvSMfrGF{ck;m*_s)?AM8kK!WEp|G~GiS~qES3H@ zQ^*uDXAn!#_T_{-gG2$9b0S9OY>c+~6oq3@;8Lw}Ht?u-QlC{-{7chMYUeW<{Fcc) z)iLMKF0{<$MGDbsS!HB2MAp4VwT7@YfO_v{>t;j2&&`w!-$mlbn|RfGz;Zv{Oi{}< z>gDw|VuE;~h9P@EFzHgMZLzw83=HZP2^N)PYH5Dl|4X@v_poWMwpMV8kTYvl#Pqy=DK%Nv~^TxTMpn0bkLwVoedY}hgWWg4D zA&?x|orf^_i`c;Xk6(;PwZkFAQ4d!;146hn(x}8NLwH&hU`}4HjF@WY#D(y5O=5kJ zt+tpSaD9T)H8HRUCZY4OBm^3Vacw{l6A~H|2_2sePu4^$PS>D$L-jEsk8Ts3tZ5jM z*?9ALBAJk6P1GaqY>`m%!A*M`%fCnDD#y=7lLYWzK$38OR!L9(F5yZ!x**zk^JB3j zk6xKymbxv<36nar*hGG6Xp%jR-G20dYsl6|X`^CQNI^aqw9k+SF{ArUT887s+g4O(qO=SSA+GrRCxsXYcLu+RnPfQs zaA0~gk;2davy}h;>qqK`fBR7J;1BHo&-<_M>+V_D{rkJ;rv5F?R~6Zw*Hzq2n(_Xkl1!NL)mt zsJ@B;UM);q+IkMLLy*kIo1Y+(39}!fN5nL#h*|MbwFjh~K_Z?>Z3S03{$eyqP)wN$ z_b#to@_;%%F0%3F$74t$Pu|FCE{;kQk{C`gr}O{*slS*y^6Q6Z4;VO#q3^7!? z+`hxS5*l}4GZuNo%PSS}#~MBPLgu{(reC_c>$`N{TEr*|p=)FN8~WF#18-hsx}iL) zjdPC5$42X|v$Ra8qJ>7P?9uuXXdkT;3DAi1YFI0h3>2E&(w))3a`rdu_M#ntb0VWn zf~mDM8cY&ZBf&G+mf6U?hq15wCEu3u2=O_{w zf;BQth;S1>W0^p#IbHok1r{rk5kEX$MjVN+gb`0)Yc*fTjcWT031I2gIBhm6(@V{k zMLfzpBe_e$i2Fv>7Bb@d2j4ZC9vQhsCXl5}v>thUyzGmN9HHz!VP6URddKUL{Qmz{ z^8f#pBOg5c#=&nKT;Bhm_E-0PVb9&&|L<;V>i4Ez9n2W8e!LuEWI{k4MRg%jn(wC1 zqqm0mEmA~Yw5hrmvu8U5%tslS&>krUbDHY+#`S>opc$EZm>ksrFcZ%kT|<< zh~050lK4z4N$ACbmh*W(CnO;x;%FrCxx*z|fUtlfENKooaI;7Z=(WxTI|MjrAaMv_ zMM#GVN!m7tfNvAj5aZ*7TGL3p}d6dwB&@y!J#POTVp9fHISbop@iv7eva=BX#yOP5>9-YDB-10 zoSEH zIq}Ij64HyR<_|N7Bcb5ViQsB?D2B9y@)CzOU;`pcH1Z3T`?P7vtD0S zurZXo<>r#YqR^Fl_moa8O%F=+pS_vlY78or(lgXf6>;;=@sGkAJguy)VO(73 ziDB7?rTJAVo7!zPZl+SK{->-wSqdzS>z$rN1;008LHpEAP?^ioDhv0D%)8wQFcyuC z|IoEL)su7-0~J`W*Xey^31NHIqJnWM&6k+3HFZ01rB7F><7&pLSO$R+To<|0EZGZ< z%m1obZ(C>_TNbsy;-BXoiKH0eG8`>6E2s=hv1&r|9i7A#G5|;t?~&TvqQwcD)2t$C zSgExcm9tvS4J3PLlr2f{_4;YClI^pn#6q?gvFRy61(H*ok|`SqZ+J|*nt|A9mQ1I%T~Eot(BDy%C%da=akpG?T#|P zDp(ChQED9;NTL%-XgcWe#=!KOqP=6an7HF&=8LbLIHGPmyzg(XOwC?d-z(JY63)ey zZrN&=)L}1unX_HJHh+dY*y(9iJJYUptm$R5eA`^G+Gm9DI3xKn%R$up13Mo2KHMv& zzN)YO$xFMxf)eAUJ65Y*Yf>5`75Kmx`0ZW_u3hCtH;dxTp3v@}5rdTK&onv%_g;t&>179g-BV0}pz-03FjvEgqYm8S{gXXS zb13;9yuLPwBOMCDl+{Sh+_Ctsb;P{EcI)6RwBn4Zn1q3Qscx%Am}u+Bj)p~0&!F9M zw^LHn9q?Ox2e#WXS<^+lHtr1<6N}bhZMiqjEq}GU(Vx>RM243aLgE4|J?%=|= zi-cfvb@q1MvX+%BpC2*ViUqgkiq$CBEP+t&T|<}*W4$Eh9PbIWb~md&RJz|X&J?yr z4C~8g%Ut67d~MBbgxB(v6|8^~0m#K}&7&A(B~#RLm3&#Z=25i;IXx-i|7h25x_tHJiaw5GIS`Ccs+(BkV^|WDw1Hto-AQkqT?co&mFGO z0)#sSu}s;>o8Y^R4s!~!*+PVaNRlOFQnQ3C3Tg;(3ZnGlx{7>T?FcCSh-|YRztF!=N_y4TU1ri9Lw6S*q zVj$cZA~R-^BnJ6qO{wJLmohw+%gv!h=m{(0{-3W8a`@D~og_rUW0 zf3^SgzR&IbcY8m&=Wjps=MP=m{nNV-?5a%tH|r1YISg5Sa&~rh>fA|@Cgim;?)z}* z+WJIuzDM?os-gTXCHO#T<-G1G6+wqlRI5c%*Q~$loC-ZWhcqRsIORmw$z6Z=AwNuW z@^BjlQznOY9z8rYZR5#mw41HAtqu#ky-aHK z98Uip7~zk}bYZOktB<#kDc(@=t^#aCPF&mHpel1A+b4|QG$M>D%Jmg9s9EiUgq3hA z7BZey$Gqs90*aF5`h@ZQBf?059vL0_qYp+zr4*=$wI4=&lSh4}La|R6-!~GB-1iox z#=Uz)cnO0Zi{7>7-+)YuMxQV~GAfKHor85Qc=52F`;=!nW=H>4E8-@NDOh%iEPK=qpf-M%~b3?RW99ckB4`zhd!YUEMbzR$HjGAfMOGy**I zf=9a{7;`8_&Nj9WM*0RNmiv{3hev`@o6&Ft1`jkm^(HgyO%9d#y!?^BQS)S_>l2TM zMuZV7T0{bKuf!urGC05+1%#Hm@u(3MfT2RE=o7|+qr#Y{8oJ(@4%ycLy!BG*ZW6>(MSV@I*{Un zB%8)FXkh*~_y+PP-!Bi}Hxi8cOa|i>b5L+RkgzvK4u=Srlms5dH>hXTuTHUdR2WsN zXp7{aei$`WD0RZ@NPd$5oc2dQx1&9tzmJP^fb=IVBj7M0$NlS zG!Qq`A52G&ADcS9?>nXrUp`(x_WIF(el&IDO;iE+^+R(9fA-*!1B?6r=lu#^CqD@W z5)335NHCCKU~Cvzf8zA;dW3-kJmr$fYijaM24+63Pd(y^Q=`I& z(-bo47hKjR4oNOuggsAn={oXFzE~)#{hqU)8Wl!p6EH)$&(s_e=suYoY^F{#8tGvUt-SY54%YoXVf^r@Fy_(*@aQdt zO_YjsCa|pFA0LePrT|T@U%Tj&qr!-4<1m7I?>h)a+-j&W#s^>+-{f<+NbC!bD=Dt# z!u#;tNfAmMrh3B@F*l>aaFfOVT*xtCrzK-gM$2k_UjD2+;U73mzqSW9^gIslj#c3U z=TTh~|LaeSUVr!l{cHBp`BGCexK(hD%wWPDYZ0fMg6p))-{5S7J(|h%wF>J`D5Fq{ z2Kxm#7wqJD7v};bcmunnuA{D;2YT_1iVe^wj3-8g(Mad=xdKcZjuqrE!dWY;Wx*K& z-r(e^t9`ER6OWGyqngg?$R*|3SA<6`O?Ak;Heq^0-vIgjN`McI1Y?H09Sbl%dheES z3yK>?oYYlV2i$lR-{7p??^=IwR2a2%p$Pu!-5G!cSp?vT0(+njM*0Tgw?8Qb)#lsi zLc34S#eAqW6;=r^a&j{nm@bRRjp5j=>kmKX=MoW&F|vEg7?g({+%x0Af!pm+n*`ne zAKj%-9Xo#Hi--T~p?e4a@W99Se|g{Dy_G#*f9UeAU&E{9$BlvY<8OvLu8OT&z(tSG zZ>ulIRdfLBFiYnYlFx~?;8{s+U*!t zi+|jId^N&LPe7={H)~Kw!kxiSVwNF-zw|IY8h=?oaW~x2Q>+j2*JcJ?pI}GN;YesD zmV}_X;gshUK{41(NJwth5lQIyod~UksnCTyJR1Fp2R#8;f#u+aA(@RgyHQ#TK+@91 z9Bxj1{{0>SzcWb0GpViMD#ts~Bmw+q^<2THw0J-r9~aqpvmHwkf%TY2FU6ijp=@XZs&7vQE3yt{Btm-%ion{EAn8OUrt|-Ssnw}t|Kjjl zhi<^n|L~rFz3T_@V6%TVKJ+2fVY(hyhp8>X2`cU&8jaluWI}6mOkmv3o^01KoP~?Ha_ry z;Va`gOljZPnU(P#9cyW+XnZBSIN`WPueXto+<^@|T4tHGfgVx6fIp%8G~x0fDI}Yi07!pP~pXw+G*k-4*-R;;uD+?Iug$(Y`G+>9N1Z*pC>(& zs3NFVn3TK_ET@U=W?KuVKT27yPKODKr)L-;x=NRP?CIy87Lv;rRQD*I{k`atSA%o) z2ZXx0f}XJKbj2z+SQSz5j_U$HbDUc~eB1-+V`uNExim?;#7O|(uqP*MHw2&*lFqAMspVp$y&Eot*A zbJo&w9kpa!%3k>Px8JbZ6Qz2s!E1uhL`#)g8?vamA{5P16Ish!wF;$`mxbU$sIhJ7b+R7W z-$+qy0jeQG)lJHEvrQ%i+a870uER3;;Rjs8t|t5{XDTW4jZQZLsU6_Xxb!HO)h z-{uyZOD3n_iq$T+YRgnMfx5kj>Oc*P=`>jWj?%0uYeNu;g}{4-P@#0190*op(owC2FBdk`4OD|<Q6@iU4@COOjfL+=yI$WzRW=h+`YFLbG7a+ zQ*QlQgGvCIoery#WQ!rN@7`*K5$(lJ>AC2dzgtkccvH0?50Ac~zS zFp#r`k*F%-e8hMtFPnq9JB*96&tYkz4dS#ldDf09WTN<&uf~y!$t{`7%N7+Uq4fbi z?>WnEiLqHV9+aSZki;S1p_?xaFSXvVx(k+a(du@H(J1Gwh1Sh(CQ~ibzbn-)uTmIr zyi5dRA{Z0F=+u42Dq|ACmQ(7Rskk6Ie`36{_LvJhZzDs(Wkl zhWP@87*~T$rm^-$$2r}5QU<7z7wy3ZIgd%g<6tD;3gZMYGmtAoVs0c_O3aP8en`hz zl*h_>cj&1Kk+~@J+o;wS$XyY}Bm25Tq$5fbe@M&wAf~U%Ei8OIz}*J2Ire`E#9Q`x zjWhH`pW`z73NtE3U1!_J31PRl&l9-TR_sgh0s8US>xS*dbGrH1(?NIaB+BBiFOz#5 znAMYeoQSKsgt12J;cIK2R15hTBm&LidSA_#=go|6&SzDtoWsRGl5S=ynpLh?MxkQq znfX!f|0(`|*WTZn+WT9$o#8GuvFhIt3SO9A8eqo=QB`}sJeTOMTA724(OjBwwPw{T z{QgFYn?A0yf>mILhRc3kXf?abC0tOH=`y)g(wU4aF#tkbbh$@B$cH-fuo%kSU(U_x zmSI2RI2f<~Ji)@3h#*SzMy;J1;Z^p|*#i1@Zvh5C>gV92)SPlu>S` zkLrtdg;iOw;1p49(ucV2PgQGm3#FFHv@%)KCTRJpFmb^r$|VPzs&LMMCwH}W7sm&Z zMeK#psycAY>C~2KV$_vWf?jC08daQpt=4%mJn^^Hg`Q6{GDXtU@?x!Cfu{)@+pJVd zWOt%dnmoo)Bl(;T1?}!qsm7hKoK3{zTZHfKa=X*A%q1IQCY;%cqPfxtduM;en0Jj! zbk9ewS2UE&=7II@SS=XYI1YvD8_K$7GU*K3^&F}?wIvJQWgU}wlC(SUAEVSfG-(w% zxv9{h_=Z}(!O@YrK6il-Q4+~~nk}NocB$H|BOnf+4oz6p4fRYjV`u`YLpk#Le(kMv313`GZqLa$e6 zfPNZm!Hm@yM!aKlI&t;k*AjYfGhmgnE&LaWaCi2kO zKeY+v1^4CRj-=Ki@it~h{(9JCt|>7TLXy=Me~g71v&7r`cjsGelrWA=6IF(D5MANAF;FUV<|*^U`23+2kf_ zH9DEcqu!3epV}TzKG8I(*#`S;yhu^juZYl^kw_*2k1F^6j5MvcW7{7IE z%ucoaW`e*8Ga<#~$z&J_5FoWu63Fu!3Y_mI!4x12C;`SJKdKp?$;u>y`2u`*C={)& zTz^rKJA*!ovLX0vQDq9R?~=(z#y>(sbVsYrzQ8gmk)gz-s7yrQwnBd2jQuSFo+W^0FtfhmRN1r77eGJ*RX9kN_rC}-~zPic5z%u>6?t}7^da9DU?w-$brD@{UAXAz<8^ov>UaE^laJf#V- zs3o(4{3jxImni{bn8;GI-GN2rj#Vi&x=Zu04-ZLi225i8FR&ejNv3cJ1~z@^oAT*q z7m~uf19h%r;p+e2u=D>ze>C;bABkXpb}C>fcyJDO;G2lOcAa|p@p^*I32pG&G7KVS z$AsmAEwWo0FxI%82Ro1~GbS+m3<2o;o8JjJoqkGbabn;4PhD~y^V;2c(srd0Zkx_{9w_L5_u23N{@Yh>{J}s6JZ^xT zkOLCkDY9KCaZ3cwP6>>^wk@XqPOJVl_8TJNc5}&^ZbI#CO_TQJZ|!-{z7aiW{?_&z zYDc~q-oqR7*I2_#`zBW2INOG6hl1vNXMZJB#h{N|uV|=%lbMGiY}`3+X){ICgLmB0 zcFcKpD?lV8a}n4+$+*R3@7rmvU!<=#%GR8GO5NK@I>--h0=xx07{H$39Fm=$N@k1M zGT8Ru30^2cLW^H7Xbh<~61dulN%_v9K8wgLLc~@alpMff$jI}6^U%RI6+VbP9EF`c z0uEa80O5403l<%&%LA)W&GXBH;IqYi@71FGkt5%-nh7F-;FY}{Ab)K=R7{noW02cgvS6|+|7 z)J!Un+pWyYeQjI?NTN*9$dX$&^D)|f`>_}F%@7=uEF--8t{=9tv&2P!FrZ!PevI?~ zUx)Yq!{l8oLqfFPq2)HwWFC?9dnaK{Qss2v!hm!R+?1>iJvtoUtNRo}qLHdvLB5 zxW&J%GmO<9Jjk{If(4IdWJ2c*ER6?fCQRhBKKvHn;lvpfB_d->!U$JoyR}iOLV9&u z7W*$9pjut05TQj%`8TxL2b-6KS|h{@aQvLjU! zb#&FlMo^-i1msP^`TyMmmw_6ahGMTxqNLmwQIhh!VWTE0PCZgXPxO>YWz~tQ5=!l3 z(^j-ZTbW30MXbw?)K;`{Xe$CiiMA4;t!$^JVlx!z`H4Bjl?_Sm>0wWriKa4fnu^VZ z5^DF_K_nv>mfF4j*}23>dIT92llva$<;0fRRm8gNNKHkTnhNFrUy-hak=N)!HFm1(VDhdA%;kSuhMWp87d8gpZ$%=ixBV0#9mNc=e`0Xl^5sXV)F%rAVMA}uv zy6i}8#gN*{D4L2uP@<_!n5JSgltfeUiZ!{XhvnUgU1j3zDmE8Ns6B+*!)}0>b%fHg z446nSH)CYdhJhTgMMIk}lq-6roGD}q*?HYEv}{GKsun8HR_Ak>VPjw6d)uai^gHrr z*L&@PQ@!itFvskecyhP@)cNho{}=0k=ds^=9OYe;1P7tN2_c)9M9&5&G+iFtxxK}{ zm>(_=TJk37i*kJ)W3Zwt9I|TXQVe!IkBoP)5zq^0jLU?$EyU)}|F^xwMqJUx-I$0+ zW>7%aVV*t-4N+3lArqE5X-MLFjogm6my~3F4v~q2((ho4A-lOqtvU`;vpY=~6lY)l zSUDLLHw1C@usZ?dG*)tvG?=g?CiFLlY9x{;fOsS?vU3O3o6XzsIdJ8A9t(vz`b~J! zX7D5@f+v8o#!WPG(}zMj30Os_MmtI=yn`});%jJ0uuTezo-qy^aPNR z6ts3vwn#O!}zHDR+y{KE&`E0HTzlK6(6t{){A5{`6nE(I) literal 0 HcmV?d00001 diff --git a/dags/sensors_and_more.py b/dags/sensors_and_more.py new file mode 100644 index 0000000..1118a53 --- /dev/null +++ b/dags/sensors_and_more.py @@ -0,0 +1,45 @@ +from __future__ import annotations + +import datetime + +import pendulum + +from airflow.models.dag import DAG +from airflow.operators.bash import BashOperator +from airflow.operators.empty import EmptyOperator + +main_dir = '/Users/palaeosaurus/Data-Projects/2024/sensors-and-more/' + +with DAG( + dag_id="sensors_and_more", + schedule="30 * * * *", + start_date=pendulum.datetime(2021, 1, 1, tz="UTC"), + catchup=False, + dagrun_timeout=datetime.timedelta(minutes=60), + tags=["example", "example2"], + params={"example_key": "example_value"}, +) as dag: + + pull_daily_data = BashOperator( + task_id='pull_daily_data', + bash_command=f"source {main_dir}venv/bin/activate && python {main_dir}download_data_from_client.py 2024-08-07 ", + ) + + merging_datasets = BashOperator( + task_id = 'bash-commands-to-merge-datasets', + bash_command = f'tail -n +2 {main_dir}data/latest_dat.csv > {main_dir}data/tmp.csv'+\ + f' && cat {main_dir}data/dat.csv {main_dir}data/tmp.csv > {main_dir}data/new_dat.csv '+ \ + f' && mv {main_dir}data/new_dat.csv {main_dir}data/dat.csv'+\ + f' && rm {main_dir}data/tmp.csv {main_dir}data/latest_dat.csv', + ) + pull_daily_data >> merging_datasets + + process_data = BashOperator( + task_id='process_data', + bash_command=f"source {main_dir}venv/bin/activate && python {main_dir}process_data.py", + ) + merging_datasets >> process_data + + +if __name__ == "__main__": + dag.test() diff --git a/standalone_admin_password.txt b/standalone_admin_password.txt new file mode 100644 index 0000000..45e55c2 --- /dev/null +++ b/standalone_admin_password.txt @@ -0,0 +1 @@ +a2EyBcdrVhB3rY45 \ No newline at end of file diff --git a/webserver_config.py b/webserver_config.py new file mode 100644 index 0000000..3048bb2 --- /dev/null +++ b/webserver_config.py @@ -0,0 +1,132 @@ +# +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. +"""Default configuration for the Airflow webserver.""" + +from __future__ import annotations + +import os + +from flask_appbuilder.const import AUTH_DB + +# from airflow.www.fab_security.manager import AUTH_LDAP +# from airflow.www.fab_security.manager import AUTH_OAUTH +# from airflow.www.fab_security.manager import AUTH_OID +# from airflow.www.fab_security.manager import AUTH_REMOTE_USER + + +basedir = os.path.abspath(os.path.dirname(__file__)) + +# Flask-WTF flag for CSRF +WTF_CSRF_ENABLED = True +WTF_CSRF_TIME_LIMIT = None + +# ---------------------------------------------------- +# AUTHENTICATION CONFIG +# ---------------------------------------------------- +# For details on how to set up each of the following authentication, see +# http://flask-appbuilder.readthedocs.io/en/latest/security.html# authentication-methods +# for details. + +# The authentication type +# AUTH_OID : Is for OpenID +# AUTH_DB : Is for database +# AUTH_LDAP : Is for LDAP +# AUTH_REMOTE_USER : Is for using REMOTE_USER from web server +# AUTH_OAUTH : Is for OAuth +AUTH_TYPE = AUTH_DB + +# Uncomment to setup Full admin role name +# AUTH_ROLE_ADMIN = 'Admin' + +# Uncomment and set to desired role to enable access without authentication +# AUTH_ROLE_PUBLIC = 'Viewer' + +# Will allow user self registration +# AUTH_USER_REGISTRATION = True + +# The recaptcha it's automatically enabled for user self registration is active and the keys are necessary +# RECAPTCHA_PRIVATE_KEY = PRIVATE_KEY +# RECAPTCHA_PUBLIC_KEY = PUBLIC_KEY + +# Config for Flask-Mail necessary for user self registration +# MAIL_SERVER = 'smtp.gmail.com' +# MAIL_USE_TLS = True +# MAIL_USERNAME = 'yourappemail@gmail.com' +# MAIL_PASSWORD = 'passwordformail' +# MAIL_DEFAULT_SENDER = 'sender@gmail.com' + +# The default user self registration role +# AUTH_USER_REGISTRATION_ROLE = "Public" + +# When using OAuth Auth, uncomment to setup provider(s) info +# Google OAuth example: +# OAUTH_PROVIDERS = [{ +# 'name':'google', +# 'token_key':'access_token', +# 'icon':'fa-google', +# 'remote_app': { +# 'api_base_url':'https://www.googleapis.com/oauth2/v2/', +# 'client_kwargs':{ +# 'scope': 'email profile' +# }, +# 'access_token_url':'https://accounts.google.com/o/oauth2/token', +# 'authorize_url':'https://accounts.google.com/o/oauth2/auth', +# 'request_token_url': None, +# 'client_id': GOOGLE_KEY, +# 'client_secret': GOOGLE_SECRET_KEY, +# } +# }] + +# When using LDAP Auth, setup the ldap server +# AUTH_LDAP_SERVER = "ldap://ldapserver.new" + +# When using OpenID Auth, uncomment to setup OpenID providers. +# example for OpenID authentication +# OPENID_PROVIDERS = [ +# { 'name': 'Yahoo', 'url': 'https://me.yahoo.com' }, +# { 'name': 'AOL', 'url': 'http://openid.aol.com/' }, +# { 'name': 'Flickr', 'url': 'http://www.flickr.com/' }, +# { 'name': 'MyOpenID', 'url': 'https://www.myopenid.com' }] + +# ---------------------------------------------------- +# Theme CONFIG +# ---------------------------------------------------- +# Flask App Builder comes up with a number of predefined themes +# that you can use for Apache Airflow. +# http://flask-appbuilder.readthedocs.io/en/latest/customizing.html#changing-themes +# Please make sure to remove "navbar_color" configuration from airflow.cfg +# in order to fully utilize the theme. (or use that property in conjunction with theme) +# APP_THEME = "bootstrap-theme.css" # default bootstrap +# APP_THEME = "amelia.css" +# APP_THEME = "cerulean.css" +# APP_THEME = "cosmo.css" +# APP_THEME = "cyborg.css" +# APP_THEME = "darkly.css" +# APP_THEME = "flatly.css" +# APP_THEME = "journal.css" +# APP_THEME = "lumen.css" +# APP_THEME = "paper.css" +# APP_THEME = "readable.css" +# APP_THEME = "sandstone.css" +# APP_THEME = "simplex.css" +# APP_THEME = "slate.css" +# APP_THEME = "solar.css" +# APP_THEME = "spacelab.css" +# APP_THEME = "superhero.css" +# APP_THEME = "united.css" +# APP_THEME = "yeti.css"